k2f_pptx 0.3.2

K2F lock → PPTX exporter
Documentation
use super::TableIndex;
use crate::align::{infer_text_align, line_spacing_spc_pts, vert_center};
use crate::coord::{millipt_to_emu, pt_to_emu};
use crate::ir::{
    BorderStroke, CellBorders, LineDash, ShapeBox, TableBox, TableCell, TableRow, TextAlign,
};
use crate::text::{cell_h_insets_emu, cell_runs, office_source_text, top_inset_emu, FontCtx};
use crate::PptxError;
use k2f_core::{
    find_in_trees, table_row_slots, table_rows_on_page, Border, BorderEdge, BorderStyle,
    GeometryNode, NodeContent, Page, PaintOp, Rect, RunningBlockNode, SemanticNode,
    TableDataSource, TextGlyphRun,
};
use k2f_paint::{parse_hex_rgba, resolve_fill};
use std::collections::{HashMap, HashSet};

pub(crate) fn table_on_page(
    index: &TableIndex,
    table_id: &str,
    page: &Page,
    ops: &[PaintOp],
    root: &SemanticNode,
    running: &[RunningBlockNode],
    fonts: &FontCtx,
) -> Result<Option<TableBox>, PptxError> {
    let Some(meta) = index.tables.get(table_id) else {
        return Ok(None);
    };
    let Some(geo) = find_geo(&page.root, table_id) else {
        return Ok(None);
    };
    let ncols = meta.column_widths.len();
    if ncols == 0 {
        return Ok(None);
    }
    let Some(table_node) = find_in_trees(root, running, table_id) else {
        return Ok(None);
    };
    let NodeContent::Table(spec) = &table_node.content else {
        return Ok(None);
    };
    let TableDataSource::Inline { rows } = &spec.data else {
        return Ok(None);
    };
    let page_rows = page_row_geos(rows, geo);
    if page_rows.is_empty() {
        return Ok(None);
    }
    let paints = cell_paints(ops)?;
    let col_widths_emu: Vec<i64> = visual_col_widths_millipt(ncols, &page_rows, geo)
        .into_iter()
        .map(|m| millipt_to_emu(i64::try_from(m.max(0)).unwrap_or(0)))
        .collect();
    let heights = row_heights_emu_from_geos(&page_rows, geo);
    let mut rows_out = Vec::with_capacity(page_rows.len());
    for (r, (sem_row, cells_geo)) in page_rows.iter().enumerate() {
        let header = r < meta.header_rows;
        let slots = table_row_slots(sem_row);
        let mut cells = Vec::with_capacity(sem_row.len());
        for (i, g) in cells_geo.iter().enumerate() {
            let slot = slots.get(i).copied().unwrap_or(k2f_core::TableCellSlot {
                start_col: i,
                span: 1,
            });
            let node = find_in_trees(root, running, &g.id);
            let paint = paints.get(&g.id);
            let no_text = paint.map(|p| p.runs.is_empty()).unwrap_or(true);
            let (runs, preserve) = cell_runs(
                node,
                paint.map(|p| p.runs.as_slice()).unwrap_or(&[]),
                Some(g),
                fonts,
                header && no_text,
            );
            let text = node.and_then(office_source_text).unwrap_or("");
            let align = if text.is_empty() {
                TextAlign::Left
            } else {
                infer_text_align(g, text)
            };
            let font_size = paint
                .and_then(|p| {
                    p.runs
                        .iter()
                        .map(|r| r.style.font_size)
                        .max_by_key(|pt| pt.0.abs())
                })
                .or_else(|| {
                    g.text_runs
                        .iter()
                        .map(|r| r.style.font_size)
                        .max_by_key(|pt| pt.0.abs())
                })
                .unwrap_or(k2f_core::Pt(12_000));
            let centered = vert_center(g, font_size);
            let mut line_spc_pts = line_spacing_spc_pts(Some(g));
            if line_spc_pts.is_none() && !runs.is_empty() {
                line_spc_pts = i32::try_from(font_size.0 / 10).ok().map(|v| v.max(100));
            }
            let (l_ins_emu, r_ins_emu) = cell_h_insets_emu(Some(g), align);
            cells.push(TableCell {
                node_id: g.id.clone(),
                runs,
                align,
                fill_hex: paint.and_then(|p| p.fill_hex.clone()),
                preserve_whitespace: preserve,
                borders: cell_borders(paint.and_then(|p| p.border.as_ref()))?,
                vert_center: centered,
                colspan: slot.span as u32,
                start_col: slot.start_col,
                t_ins_emu: if centered { 0 } else { top_inset_emu(Some(g)) },
                l_ins_emu,
                r_ins_emu,
                line_spc_pts,
            });
        }
        rows_out.push(TableRow {
            height_emu: heights.get(r).copied().unwrap_or(0),
            cells,
        });
    }
    Ok(Some(TableBox {
        node_id: table_id.to_string(),
        x_emu: pt_to_emu(geo.x),
        y_emu: pt_to_emu(geo.y),
        cx_emu: pt_to_emu(geo.width),
        cy_emu: pt_to_emu(geo.height),
        col_widths_emu,
        rows: rows_out,
    }))
}

pub(crate) fn table_ref_placeholder(node_id: &str, rect: &Rect) -> ShapeBox {
    ShapeBox {
        node_id: node_id.to_string(),
        x_emu: pt_to_emu(rect.x),
        y_emu: pt_to_emu(rect.y),
        cx_emu: pt_to_emu(rect.width),
        cy_emu: pt_to_emu(rect.height),
            fill_hex: None,
            fill_alpha: 255,
            gradient: None,
            corner_emu: 0,
        line_hex: Some("D0D0D0".into()),
        line_alpha: 255,
        line_w_emu: millipt_to_emu(1_000),
        line_dash: LineDash::Solid,
    }
}

struct CellPaint {
    fill_hex: Option<String>,
    border: Option<Border>,
    runs: Vec<TextGlyphRun>,
}

impl CellPaint {
    fn empty() -> Self {
        Self {
            fill_hex: None,
            border: None,
            runs: Vec::new(),
        }
    }
}

fn cell_paints(ops: &[PaintOp]) -> Result<HashMap<String, CellPaint>, PptxError> {
    let mut map: HashMap<String, CellPaint> = HashMap::new();
    for op in ops {
        match op {
            PaintOp::DrawBox {
                node_id,
                decoration,
                ..
            } => {
                let fill = opaque_solid_hex(decoration)?;
                let e = map.entry(node_id.clone()).or_insert_with(CellPaint::empty);
                e.fill_hex = fill;
                e.border = decoration.border.clone();
            }
            PaintOp::DrawText { node_id, runs, .. } => {
                map.entry(node_id.clone())
                    .or_insert_with(CellPaint::empty)
                    .runs = runs.clone();
            }
            _ => {}
        }
    }
    Ok(map)
}

fn cell_borders(border: Option<&Border>) -> Result<CellBorders, PptxError> {
    let Some(b) = border else {
        return Ok(CellBorders::default());
    };
    if b.width_pt <= 0 || b.edges.is_empty() {
        return Ok(CellBorders::default());
    }
    let stroke = BorderStroke {
        color_hex: srgb_hex(&b.color)?,
        w_emu: millipt_to_emu(b.width_pt).max(1),
        dash: match b.style {
            BorderStyle::Solid => LineDash::Solid,
            BorderStyle::Dashed => LineDash::Dash,
            BorderStyle::Dotted => LineDash::Dot,
        },
    };
    Ok(CellBorders {
        top: edge(b, BorderEdge::Top, &stroke),
        left: edge(b, BorderEdge::Left, &stroke),
        bottom: edge(b, BorderEdge::Bottom, &stroke),
        right: edge(b, BorderEdge::Right, &stroke),
    })
}

fn edge(b: &Border, e: BorderEdge, stroke: &BorderStroke) -> Option<BorderStroke> {
    b.draws_edge(e).then(|| stroke.clone())
}

fn srgb_hex(color: &str) -> Result<String, PptxError> {
    let [r, g, b, _] = parse_hex_rgba(color)
        .ok_or_else(|| PptxError::Write(format!("unparseable color '{color}'")))?;
    Ok(crate::text::pin_office_srgb(&format!(
        "{r:02X}{g:02X}{b:02X}"
    )))
}

fn opaque_solid_hex(decoration: &k2f_core::BoxDecoration) -> Result<Option<String>, PptxError> {
    match resolve_fill(decoration) {
        Ok(Some(k2f_core::Fill::Solid { color })) => {
            let [r, g, b, a] = parse_hex_rgba(&color)
                .ok_or_else(|| PptxError::Write(format!("unparseable fill color '{color}'")))?;
            if a < 255 {
                return Ok(None);
            }
            Ok(Some(crate::text::pin_office_srgb(&format!(
                "{r:02X}{g:02X}{b:02X}"
            ))))
        }
        Ok(_) => Ok(None),
        Err(k2f_paint::PaintError::UnresolvedRef(name)) => {
            Err(PptxError::Write(format!("unresolved fill ref '{name}'")))
        }
        Err(e) => Err(e.into()),
    }
}

fn find_geo<'a>(node: &'a GeometryNode, id: &str) -> Option<&'a GeometryNode> {
    if node.id == id {
        return Some(node);
    }
    node.children.iter().find_map(|c| find_geo(c, id))
}

fn page_row_geos<'a>(
    rows: &'a [Vec<SemanticNode>],
    geo: &'a GeometryNode,
) -> Vec<(&'a [SemanticNode], Vec<&'a GeometryNode>)> {
    let present: HashSet<&str> = geo.children.iter().map(|c| c.id.as_str()).collect();
    let by_id: HashMap<&str, &GeometryNode> =
        geo.children.iter().map(|c| (c.id.as_str(), c)).collect();
    table_rows_on_page(rows, &present)
        .into_iter()
        .filter_map(|row| {
            let geos: Vec<&GeometryNode> = row
                .iter()
                .map(|c| by_id.get(c.id.as_str()).copied())
                .collect::<Option<Vec<_>>>()?;
            Some((row, geos))
        })
        .collect()
}

fn col_widths_from_geos(row: &[&GeometryNode], table: &GeometryNode) -> Vec<i128> {
    let n = row.len();
    (0..n)
        .map(|i| {
            if i + 1 < n {
                row[i + 1].x.0 - row[i].x.0
            } else {
                (table.x.0 + table.width.0) - row[i].x.0
            }
            .max(0)
        })
        .collect()
}

fn visual_col_widths_millipt(
    ncols: usize,
    page_rows: &[(&[SemanticNode], Vec<&GeometryNode>)],
    table: &GeometryNode,
) -> Vec<i128> {
    for (sem, geos) in page_rows {
        let slots = table_row_slots(sem);
        if slots.len() == ncols && slots.iter().all(|s| s.span == 1) && geos.len() == ncols {
            return col_widths_from_geos(geos, table);
        }
    }
    let mut xs = vec![None; ncols + 1];
    xs[ncols] = Some(table.x.0 + table.width.0);
    for (sem, geos) in page_rows {
        let slots = table_row_slots(sem);
        for (i, slot) in slots.iter().enumerate() {
            let Some(g) = geos.get(i) else { continue };
            xs[slot.start_col] = Some(g.x.0);
            let end = slot.start_col + slot.span;
            if end < ncols {
                if let Some(next) = geos.get(i + 1) {
                    xs[end] = Some(next.x.0);
                }
            }
        }
    }
    if xs[0].is_none() {
        xs[0] = Some(table.x.0);
    }
    fill_missing_xs(&mut xs);
    (0..ncols)
        .map(|i| (xs[i + 1].unwrap_or(0) - xs[i].unwrap_or(0)).max(0))
        .collect()
}

fn fill_missing_xs(xs: &mut [Option<i128>]) {
    let n = xs.len();
    let mut i = 0;
    while i < n {
        if xs[i].is_some() {
            i += 1;
            continue;
        }
        let left_i = i.saturating_sub(1);
        let left = xs[left_i];
        let mut j = i;
        while j < n && xs[j].is_none() {
            j += 1;
        }
        let right = if j < n { xs[j] } else { None };
        match (left, right) {
            (Some(l), Some(r)) => {
                let span = (j - left_i) as i128;
                if span <= 0 {
                    i = j;
                    continue;
                }
                for k in i..j {
                    xs[k] = Some(l + (r - l) * (k as i128 - left_i as i128) / span);
                }
            }
            (Some(l), None) => {
                for k in i..j {
                    xs[k] = Some(l);
                }
            }
            (None, Some(r)) => {
                for k in i..j {
                    xs[k] = Some(r);
                }
            }
            _ => {
                for k in i..j {
                    xs[k] = Some(0);
                }
            }
        }
        i = j;
    }
}

fn row_heights_emu_from_geos(
    rows: &[(&[SemanticNode], Vec<&GeometryNode>)],
    table: &GeometryNode,
) -> Vec<i64> {
    rows.iter()
        .enumerate()
        .map(|(i, (_, row))| {
            let y = row.first().map(|c| c.y.0).unwrap_or(table.y.0);
            let next_y = rows
                .get(i + 1)
                .and_then(|(_, r)| r.first())
                .map(|c| c.y.0)
                .unwrap_or(table.y.0 + table.height.0);
            let from_gap = next_y - y;
            let from_cell = row.iter().map(|c| c.height.0).max().unwrap_or(0);
            millipt_to_emu(i64::try_from(from_gap.max(from_cell).max(0)).unwrap_or(0))
        })
        .collect()
}