mirror of
https://github.com/storytold/cadcraft.git
synced 2026-11-09 03:50:04 -06:00
430 lines
17 KiB
Rust
430 lines
17 KiB
Rust
//! TABLE geometry from the table's cell styles: cell fills, borders and texts. Shared by the
|
||
//! display list and the DXF writer (which stores the same geometry as the table's block).
|
||
|
||
use std::collections::HashMap;
|
||
|
||
use cadcraft_color::Color;
|
||
use cadcraft_doc::{CellBorder, CellStyle, Drawing, Lineweight, Table, TableStyle};
|
||
use cadcraft_geom::Vec2;
|
||
|
||
use crate::{Builder, Ctx, Ink, ink};
|
||
|
||
/// The most cells laid out (rows × columns); larger tables draw only their outline.
|
||
pub const MAX_LAYOUT_CELLS: usize = 1_000_000;
|
||
|
||
/// A border segment.
|
||
#[derive(Clone, Debug, PartialEq)]
|
||
pub struct TableLine {
|
||
pub a: Vec2,
|
||
pub b: Vec2,
|
||
pub color: Color,
|
||
pub lineweight: Lineweight,
|
||
}
|
||
|
||
/// A cell background.
|
||
#[derive(Clone, Debug, PartialEq)]
|
||
pub struct TableFill {
|
||
/// Corners, counter-clockwise from the bottom left.
|
||
pub corners: [Vec2; 4],
|
||
pub color: Color,
|
||
}
|
||
|
||
/// A cell's text, placed at its alignment point.
|
||
#[derive(Clone, Debug, PartialEq)]
|
||
pub struct TableText {
|
||
pub row: usize,
|
||
pub col: usize,
|
||
pub at: Vec2,
|
||
/// MTEXT attachment (1 top left … 9 bottom right).
|
||
pub attach: u8,
|
||
pub height: f64,
|
||
pub color: Color,
|
||
pub style: String,
|
||
pub text: String,
|
||
}
|
||
|
||
/// Everything a table draws, in world coordinates.
|
||
#[derive(Clone, Debug, Default, PartialEq)]
|
||
pub struct TableGeom {
|
||
pub fills: Vec<TableFill>,
|
||
pub lines: Vec<TableLine>,
|
||
pub texts: Vec<TableText>,
|
||
}
|
||
|
||
/// Which cells are covered by a merge (and so not drawn on their own).
|
||
pub fn table_covered(t: &Table) -> Vec<Vec<bool>> {
|
||
coverage(t).unwrap_or_else(|partial| partial)
|
||
}
|
||
|
||
// No partial coverage may reach owner assignment: it would revisit unbounded merge rectangles.
|
||
/// Mark cells covered by merges under grid-size and marking-work limits.
|
||
/// Return partial coverage as an error so layout can use its outline fallback instead of assigning owners.
|
||
fn coverage(t: &Table) -> Result<Vec<Vec<bool>>, Vec<Vec<bool>>> {
|
||
let rows = t.row_heights.len().min(10_000);
|
||
let cols = t.col_widths.len().min(10_000);
|
||
if rows.saturating_mul(cols) > MAX_LAYOUT_CELLS {
|
||
return Err(vec![Vec::new(); rows]);
|
||
}
|
||
let mut cov = vec![vec![false; cols]; rows];
|
||
// Coverage marking visits each merge's whole rectangle. Overlapping merges re-mark cells that
|
||
// are already covered, so bound the total marking steps to a small multiple of the cell count
|
||
// rather than letting overlapping declarations cause quadratic work (CWE-407).
|
||
let mut budget: u64 = (rows as u64).saturating_mul(cols as u64).saturating_mul(4).saturating_add(1024);
|
||
for (r, row) in t.cells.iter().enumerate().take(rows) {
|
||
for (c, cell) in row.iter().enumerate().take(cols) {
|
||
if let Some((rs, cs)) = cell.merged {
|
||
for rr in r..(r + rs.max(1) as usize).min(rows) {
|
||
for cc in c..(c + cs.max(1) as usize).min(cols) {
|
||
budget = budget.saturating_sub(1);
|
||
if budget == 0 {
|
||
return Err(cov);
|
||
}
|
||
if (rr, cc) != (r, c)
|
||
&& let Some(x) = cov.get_mut(rr).and_then(|v| v.get_mut(cc))
|
||
{
|
||
*x = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
Ok(cov)
|
||
}
|
||
|
||
/// The table style a table uses (Standard defaults when missing).
|
||
pub fn table_style_of(d: &Drawing, t: &Table) -> TableStyle {
|
||
d.table_styles.iter().find(|s| s.name.eq_ignore_ascii_case(&t.style)).cloned().unwrap_or_default()
|
||
}
|
||
|
||
/// The scale of a table relative to its style: SCALE changes the table's text height, and every
|
||
/// cell style height and margin follows.
|
||
fn style_scale(st: &TableStyle, t: &Table) -> f64 {
|
||
// A table from another writer is resolved to its style's height on reading (scale 1); a
|
||
// non-positive height here is the same "no scale of its own".
|
||
let k = t.text_height / st.text_height;
|
||
if k.is_finite() && k > 0.0 { k } else { 1.0 }
|
||
}
|
||
|
||
/// Column and row edge offsets (x right, y down from the insertion point).
|
||
fn edges(sizes: &[f64], n: usize) -> Vec<f64> {
|
||
let mut out = Vec::with_capacity(n + 1);
|
||
out.push(0.0);
|
||
let mut acc = 0.0;
|
||
for s in sizes.iter().take(n) {
|
||
acc += if s.is_finite() { *s } else { 0.0 };
|
||
out.push(acc);
|
||
}
|
||
out
|
||
}
|
||
|
||
/// A merged cell (or a plain one): its anchor, span and cell style.
|
||
struct Anchor {
|
||
row: usize,
|
||
col: usize,
|
||
rows: usize,
|
||
cols: usize,
|
||
style: usize,
|
||
}
|
||
|
||
/// Lay out table `t` of drawing `d`, every part of a broken table.
|
||
pub fn table_geometry(d: &Drawing, t: &Table) -> TableGeom {
|
||
let parts = t.parts();
|
||
if parts.len() <= 1 {
|
||
return layout(d, t);
|
||
}
|
||
let mut g = TableGeom::default();
|
||
for p in parts {
|
||
let mut pg = layout(d, &part_table(t, &p.rows, p.origin));
|
||
for tx in &mut pg.texts {
|
||
tx.row = p.rows.get(tx.row).copied().unwrap_or(tx.row);
|
||
}
|
||
g.fills.extend(pg.fills);
|
||
g.lines.extend(pg.lines);
|
||
g.texts.extend(pg.texts);
|
||
}
|
||
g
|
||
}
|
||
|
||
/// One part of a broken table as a table of its own: its rows (with their cell styles) at
|
||
/// `origin`; merges are cut at the part's edge.
|
||
fn part_table(t: &Table, rows: &[usize], origin: Vec2) -> Table {
|
||
let cols = t.col_widths.len().min(10_000);
|
||
let mut cells: Vec<Vec<cadcraft_doc::TableCell>> =
|
||
rows.iter().take(10_000).map(|r| t.cells.get(*r).map(|row| row.iter().take(cols).cloned().collect()).unwrap_or_default()).collect();
|
||
// Only expand sparse rows to the full column count when detailed layout is actually permitted.
|
||
// Otherwise `layout` renders an outline, so materialising millions of empty cells here would be
|
||
// wasted work an attacker can trigger with a compact dimension array (CWE-789).
|
||
if rows.len().min(10_000).saturating_mul(cols) <= MAX_LAYOUT_CELLS {
|
||
for (i, row) in cells.iter_mut().enumerate() {
|
||
row.resize_with(cols, Default::default);
|
||
for cell in row.iter_mut() {
|
||
if let Some((rs, cs)) = cell.merged {
|
||
// Rows of the merge that follow in this part.
|
||
let start = rows.get(i).copied().unwrap_or(0);
|
||
let mut n = 1u32;
|
||
while n < rs && rows.get(i + n as usize).is_some_and(|r| *r == start + n as usize) {
|
||
n += 1;
|
||
}
|
||
cell.merged = (n > 1 || cs > 1).then_some((n, cs));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
Table {
|
||
insert: origin.to3(t.insert.z),
|
||
col_widths: t.col_widths.clone(),
|
||
row_heights: rows.iter().map(|r| t.row_heights.get(*r).copied().unwrap_or(0.0)).collect(),
|
||
row_styles: rows.iter().map(|r| t.row_style(*r).to_string()).collect(),
|
||
cells,
|
||
style: t.style.clone(),
|
||
text_height: t.text_height,
|
||
title: false,
|
||
header: false,
|
||
breaks: None,
|
||
data_link: None,
|
||
}
|
||
}
|
||
|
||
/// Lay out one part.
|
||
fn layout(d: &Drawing, t: &Table) -> TableGeom {
|
||
let st = table_style_of(d, t);
|
||
let rows = t.row_heights.len().min(10_000);
|
||
let cols = t.col_widths.len().min(10_000);
|
||
let xs = edges(&t.col_widths, cols);
|
||
let ys = edges(&t.row_heights, rows);
|
||
let o = t.insert.xy();
|
||
let p = |x: f64, y: f64| o + Vec2::new(x, -y);
|
||
let x_at = |c: usize| xs.get(c).copied().unwrap_or(0.0);
|
||
let y_at = |r: usize| ys.get(r).copied().unwrap_or(0.0);
|
||
let mut g = TableGeom::default();
|
||
if rows == 0 || cols == 0 {
|
||
return g;
|
||
}
|
||
let cov = coverage(t);
|
||
if rows.saturating_mul(cols) > MAX_LAYOUT_CELLS || cov.is_err() {
|
||
let (w, h) = (x_at(cols), y_at(rows));
|
||
let corners = [p(0.0, 0.0), p(w, 0.0), p(w, h), p(0.0, h), p(0.0, 0.0)];
|
||
for s in corners.windows(2) {
|
||
if let [a, b] = s {
|
||
g.lines.push(TableLine { a: *a, b: *b, color: Color::ByBlock, lineweight: Lineweight::ByBlock });
|
||
}
|
||
}
|
||
return g;
|
||
}
|
||
let k = style_scale(&st, t);
|
||
// Cell styles by name, scaled to the table.
|
||
let mut styles: Vec<CellStyle> = Vec::new();
|
||
let mut by_name: HashMap<String, usize> = HashMap::new();
|
||
let mut style_index = |name: &str| -> usize {
|
||
let key = name.to_ascii_lowercase();
|
||
if let Some(i) = by_name.get(&key) {
|
||
return *i;
|
||
}
|
||
let mut cs = st.cell_style(name);
|
||
cs.text_height *= k;
|
||
cs.margin_h *= k;
|
||
cs.margin_v *= k;
|
||
styles.push(cs);
|
||
let i = styles.len() - 1;
|
||
by_name.insert(key, i);
|
||
i
|
||
};
|
||
// Anchors and the anchor owning each grid cell.
|
||
let cov = cov.unwrap_or_default();
|
||
let mut anchors: Vec<Anchor> = Vec::new();
|
||
let mut owner = vec![usize::MAX; rows * cols];
|
||
for r in 0..rows {
|
||
for c in 0..cols {
|
||
if cov.get(r).and_then(|v| v.get(c)).copied().unwrap_or(false) {
|
||
continue;
|
||
}
|
||
let cell = t.cells.get(r).and_then(|row| row.get(c));
|
||
let (rs, cs) = cell.and_then(|x| x.merged).map(|(a, b)| (a.max(1) as usize, b.max(1) as usize)).unwrap_or((1, 1));
|
||
let (rs, cs) = (rs.min(rows - r), cs.min(cols - c));
|
||
let style = style_index(t.cell_style_name(r, c));
|
||
let id = anchors.len();
|
||
for rr in r..r + rs {
|
||
for cc in c..c + cs {
|
||
if let Some(x) = owner.get_mut(rr * cols + cc)
|
||
&& *x == usize::MAX
|
||
{
|
||
*x = id;
|
||
}
|
||
}
|
||
}
|
||
anchors.push(Anchor { row: r, col: c, rows: rs, cols: cs, style });
|
||
}
|
||
}
|
||
let own = |r: usize, c: usize| owner.get(r * cols + c).copied().filter(|x| *x != usize::MAX);
|
||
let style_of = |a: Option<usize>| a.and_then(|a| anchors.get(a)).and_then(|a| styles.get(a.style));
|
||
let same_style = |a: Option<usize>, b: Option<usize>| matches!((a.and_then(|a| anchors.get(a)), b.and_then(|b| anchors.get(b))), (Some(x), Some(y)) if x.style == y.style);
|
||
// Fills first, under the borders and texts.
|
||
for a in &anchors {
|
||
let Some(cs) = styles.get(a.style) else { continue };
|
||
if let Some(fill) = cs.fill {
|
||
let (x0, x1, y0, y1) = (x_at(a.col), x_at(a.col + a.cols), y_at(a.row), y_at(a.row + a.rows));
|
||
g.fills.push(TableFill { corners: [p(x0, y1), p(x1, y1), p(x1, y0), p(x0, y0)], color: fill });
|
||
}
|
||
}
|
||
// Borders: one segment per grid edge between different cells, joined while unchanged.
|
||
let push = |g: &mut TableGeom, a: Vec2, b: Vec2, br: Option<CellBorder>| {
|
||
let Some(br) = br.filter(|b| b.visible) else { return };
|
||
if let Some(last) = g.lines.last_mut()
|
||
&& last.b == a
|
||
&& last.color == br.color
|
||
&& last.lineweight == br.lineweight
|
||
&& (last.b - last.a).cross(b - a).abs() <= 1e-12 * (1.0 + (last.b - last.a).len() * (b - a).len())
|
||
{
|
||
last.b = b;
|
||
return;
|
||
}
|
||
g.lines.push(TableLine { a, b, color: br.color, lineweight: br.lineweight });
|
||
};
|
||
for i in 0..=rows {
|
||
for c in 0..cols {
|
||
let above = if i > 0 { own(i - 1, c) } else { None };
|
||
let below = if i < rows { own(i, c) } else { None };
|
||
if above.is_some() && above == below {
|
||
continue;
|
||
}
|
||
let br = match (style_of(above), style_of(below)) {
|
||
(None, Some(b)) => Some(b.borders.top),
|
||
(Some(a), None) => Some(a.borders.bottom),
|
||
(Some(a), Some(_)) if same_style(above, below) => Some(a.borders.inside_h),
|
||
(Some(a), Some(b)) => Some(CellBorder { visible: a.borders.bottom.visible && b.borders.top.visible, ..b.borders.top }),
|
||
(None, None) => None,
|
||
};
|
||
push(&mut g, p(x_at(c), y_at(i)), p(x_at(c + 1), y_at(i)), br);
|
||
}
|
||
}
|
||
for j in 0..=cols {
|
||
for r in 0..rows {
|
||
let left = if j > 0 { own(r, j - 1) } else { None };
|
||
let right = if j < cols { own(r, j) } else { None };
|
||
if left.is_some() && left == right {
|
||
continue;
|
||
}
|
||
let br = match (style_of(left), style_of(right)) {
|
||
(None, Some(b)) => Some(b.borders.left),
|
||
(Some(a), None) => Some(a.borders.right),
|
||
(Some(a), Some(_)) if same_style(left, right) => Some(a.borders.inside_v),
|
||
(Some(a), Some(b)) => Some(CellBorder { visible: a.borders.right.visible && b.borders.left.visible, ..b.borders.left }),
|
||
(None, None) => None,
|
||
};
|
||
push(&mut g, p(x_at(j), y_at(r)), p(x_at(j), y_at(r + 1)), br);
|
||
}
|
||
}
|
||
// Texts at their alignment point inside the margins.
|
||
for a in &anchors {
|
||
let Some(cell) = t.cells.get(a.row).and_then(|row| row.get(a.col)).filter(|c| !c.text.is_empty()) else { continue };
|
||
let Some(cs) = styles.get(a.style) else { continue };
|
||
let (x0, x1, y0, y1) = (x_at(a.col), x_at(a.col + a.cols), y_at(a.row), y_at(a.row + a.rows));
|
||
let attach = cs.align.clamp(1, 9);
|
||
let x = match (attach - 1) % 3 {
|
||
0 => x0 + cs.margin_h,
|
||
1 => (x0 + x1) / 2.0,
|
||
_ => x1 - cs.margin_h,
|
||
};
|
||
let y = match (attach - 1) / 3 {
|
||
0 => y0 + cs.margin_v,
|
||
1 => (y0 + y1) / 2.0,
|
||
_ => y1 - cs.margin_v,
|
||
};
|
||
g.texts.push(TableText {
|
||
row: a.row,
|
||
col: a.col,
|
||
at: p(x, y),
|
||
attach,
|
||
height: cell.text_height.filter(|h| h.is_finite() && *h > 0.0).map_or(cs.text_height, |h| h * k),
|
||
color: cs.text_color,
|
||
style: cs.text_style.clone(),
|
||
text: cell.text.clone(),
|
||
});
|
||
}
|
||
g
|
||
}
|
||
|
||
/// A cell style colour as drawn: ByBlock / ByLayer take the table's colour.
|
||
fn style_ink(c: Color, table: Ink) -> Ink {
|
||
match c {
|
||
Color::ByBlock | Color::ByLayer => table,
|
||
c => ink(c, Color::Index(7), Color::Index(7)),
|
||
}
|
||
}
|
||
|
||
/// Draw a table into the display list.
|
||
pub(crate) fn draw(b: &mut Builder, ctx: &Ctx, t: &Table, rgb: Ink, lw: f32) {
|
||
let g = table_geometry(ctx.d, t);
|
||
if b.opts.fill {
|
||
for f in &g.fills {
|
||
let [a, bb, c, dd] = f.corners;
|
||
b.tris(ctx, style_ink(f.color, rgb), &[a, bb, c, a, c, dd]);
|
||
}
|
||
}
|
||
for l in &g.lines {
|
||
let w = match l.lineweight {
|
||
Lineweight::Mm100(v) => f32::from(v) / 100.0,
|
||
Lineweight::Default => crate::default_lineweight(ctx.d),
|
||
Lineweight::ByBlock | Lineweight::ByLayer => lw,
|
||
};
|
||
b.polyline(ctx, style_ink(l.color, rgb), w, &[l.a, l.b]);
|
||
}
|
||
if !b.opts.text {
|
||
return;
|
||
}
|
||
for tx in &g.texts {
|
||
let ts = crate::text_style(ctx.d, &tx.style);
|
||
let font = cadcraft_fonts::TextFont::resolve(&ts.font);
|
||
// Cell content is MTEXT (`\P`, `{\Q15;…}`, `\F…;`): laid out as such, at the cell's
|
||
// alignment point (its numbering is MTEXT's attachment).
|
||
let mp = cadcraft_fonts::MTextParams {
|
||
attach: tx.attach,
|
||
font,
|
||
width_factor: ts.width_factor,
|
||
oblique: ts.oblique,
|
||
..cadcraft_fonts::MTextParams::new(tx.at, tx.height)
|
||
};
|
||
let layout = cadcraft_fonts::layout_mtext_with(&tx.text, &mp);
|
||
for piece in &layout.pieces {
|
||
b.shaped(ctx, style_ink(tx.color, rgb), lw, &piece.shaped);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod budget_tests {
|
||
use super::*;
|
||
use cadcraft_doc::TableCell;
|
||
|
||
/// Excessive overlapping merges draw only the table outline after coverage work is exhausted.
|
||
#[test]
|
||
fn overlapping_merges_use_outline_fallback() {
|
||
let t = Table {
|
||
row_heights: vec![1.0; 40],
|
||
col_widths: vec![1.0; 40],
|
||
cells: vec![vec![TableCell { merged: Some((40, 40)), ..Default::default() }; 40]; 40],
|
||
..Default::default()
|
||
};
|
||
assert!(coverage(&t).is_err());
|
||
let g = layout(&Drawing::default(), &t);
|
||
assert_eq!(g.lines.len(), 4);
|
||
assert!(g.fills.is_empty() && g.texts.is_empty());
|
||
}
|
||
|
||
/// A split table within the displayed-cell budget clips a merge to contiguous selected rows.
|
||
#[test]
|
||
fn part_clips_merges_using_displayed_column_count() {
|
||
let t = Table {
|
||
row_heights: vec![1.0; 102],
|
||
col_widths: vec![1.0; 10_001],
|
||
cells: vec![vec![TableCell { merged: Some((100, 1)), ..Default::default() }]],
|
||
..Default::default()
|
||
};
|
||
let mut rows: Vec<_> = (0..99).collect();
|
||
rows.push(101);
|
||
let part = part_table(&t, &rows, Vec2::ZERO);
|
||
assert_eq!(part.cells[0][0].merged, Some((99, 1)));
|
||
}
|
||
}
|