k2f_pptx 0.2.3

K2F lock → PPTX exporter
Documentation
use crate::coord::pt_to_emu;
use crate::effect::{
    box_is_effect, consume_following_box, effect_box_crop, glass_crop, is_math_node, is_rule_id,
    keep_for_effect, math_crop, rasterize_slice,
};
use crate::ir::{DeckIR, SlideElement, SlideIR};
use crate::picture::picture_from_draw;
use crate::shape::shape_from_box;
use crate::table::{index_native_tables, paint_node_id, table_on_page, table_ref_placeholder};
use crate::text::{list_start_at, textbox_from_draw, FontCtx};
use crate::PptxError;
use k2f_core::{Fill, GeometryNode, Page, PaintOp, Pt, Rect};
use k2f_paint::{parse_hex_rgba, resolve_fill, OpenedDocument};
use std::collections::HashSet;

pub fn classify_opened(doc: &OpenedDocument) -> Result<DeckIR, PptxError> {
    let lock = doc.lock().ok_or(PptxError::Unlocked)?;
    if lock.has_unknown_paint_ops() {
        return Err(PptxError::UnknownOp);
    }
    let pages = &lock.geometry.pages;
    if pages.is_empty() {
        return Err(PptxError::Write("lock has no pages".into()));
    }
    let fonts = FontCtx::new(doc.fonts());
    let root = doc.semantic_root();
    let running = doc.running_blocks();
    let assets = doc.assets();
    let tables = index_native_tables(root, running);
    let list_starts = list_start_at(root);
    let mut media_n = 1u32;
    let mut raster_n = 1u32;
    let total_pages = pages.len();
    let mut slides = Vec::with_capacity(total_pages);
    for (page_idx, page) in pages.iter().enumerate() {
        let plan = lock
            .render_plan
            .pages
            .iter()
            .find(|p| p.index == page.index)
            .ok_or(k2f_paint::PaintError::MissingRenderPlan(page.index))?;
        let mut elements = Vec::new();
        let mut emitted_tables = HashSet::new();
        let mut skip = HashSet::new();
        for (i, op) in plan.ops.iter().enumerate() {
            if skip.contains(&i) {
                continue;
            }
            if let Some(tid) = paint_node_id(op).and_then(|id| tables.owner_of(id)) {
                if emitted_tables.contains(tid) {
                    continue;
                }
                if let Some(tbl) =
                    table_on_page(&tables, tid, page, &plan.ops, root, running, &fonts)?
                {
                    emitted_tables.insert(tid.to_string());
                    elements.push(SlideElement::Table(tbl));
                    continue;
                }
            }
            match op {
                PaintOp::Unknown => return Err(PptxError::UnknownOp),
                PaintOp::BackdropBlur { node_id, rect, .. } => {
                    let follow = consume_following_box(&plan.ops, i, node_id);
                    if let Some(j) = follow {
                        skip.insert(j);
                    }
                    let crop = glass_crop(rect, &plan.ops, follow)?;
                    let keep = keep_for_effect(node_id, page, false);
                    let pic = rasterize_slice(
                        lock,
                        page_idx,
                        page,
                        &plan.ops,
                        &keep,
                        crop,
                        node_id,
                        raster_n,
                        doc.fonts(),
                        assets,
                    )?;
                    raster_n = raster_n.saturating_add(1);
                    elements.push(SlideElement::Raster(pic));
                }
                PaintOp::DrawText {
                    node_id,
                    rect,
                    runs,
                } => {
                    let Some(node) = k2f_core::find_in_trees(root, running, node_id) else {
                        continue;
                    };
                    if is_math_node(node) {
                        let crop = math_crop(&plan.ops, node_id, rect);
                        let keep = keep_for_effect(node_id, page, true);
                        let pic = rasterize_slice(
                            lock,
                            page_idx,
                            page,
                            &plan.ops,
                            &keep,
                            crop,
                            node_id,
                            raster_n,
                            doc.fonts(),
                            assets,
                        )?;
                        raster_n = raster_n.saturating_add(1);
                        elements.push(SlideElement::Raster(pic));
                    } else {
                        let geo = find_geo(&page.root, node_id);
                        if let Some(tb) = textbox_from_draw(
                            node,
                            rect,
                            runs,
                            geo,
                            &fonts,
                            page_idx,
                            total_pages,
                            list_starts.get(&node.id).copied().unwrap_or(1),
                        ) {
                            elements.push(SlideElement::TextBox(tb));
                        }
                    }
                }
                PaintOp::DrawBox {
                    node_id,
                    rect,
                    decoration,
                } => {
                    if is_rule_id(node_id) {
                        continue;
                    }
                    if box_is_effect(node_id, decoration)? {
                        let crop = effect_box_crop(rect, decoration)?;
                        let keep = keep_for_effect(node_id, page, false);
                        let pic = rasterize_slice(
                            lock,
                            page_idx,
                            page,
                            &plan.ops,
                            &keep,
                            crop,
                            node_id,
                            raster_n,
                            doc.fonts(),
                            assets,
                        )?;
                        raster_n = raster_n.saturating_add(1);
                        elements.push(SlideElement::Raster(pic));
                    } else if let Some(shape) = shape_from_box(node_id, rect, decoration)? {
                        elements.push(SlideElement::Shape(shape));
                    }
                }
                PaintOp::DrawImage { node_id, rect, src } => {
                    let pic = picture_from_draw(node_id, rect, src, assets, media_n)?;
                    media_n = media_n.saturating_add(1);
                    elements.push(SlideElement::Picture(pic));
                }
                PaintOp::DrawTableReference { node_id, rect, .. } => {
                    elements.push(SlideElement::Shape(table_ref_placeholder(node_id, rect)));
                }
            }
        }
        let bg_hex = page_bg_hex(page, &plan.ops);
        assign_table_cell_underlays(&mut elements, &bg_hex);
        slides.push(SlideIR {
            width_emu: pt_to_emu(page.width),
            height_emu: pt_to_emu(page.height),
            bg_hex,
            elements,
        });
    }
    Ok(DeckIR {
        title: doc.title().to_string(),
        slides,
    })
}

fn page_bg_hex(page: &Page, ops: &[PaintOp]) -> String {
    let raw = match ops.first() {
        Some(PaintOp::DrawBox {
            rect, decoration, ..
        }) if is_full_page(page, rect) => match resolve_fill(decoration) {
            Ok(Some(Fill::Solid { color })) => {
                opaque_srgb_hex(&color).unwrap_or_else(|| "FFFFFF".into())
            }
            _ => "FFFFFF".into(),
        },
        _ => "FFFFFF".into(),
    };
    crate::text::pin_office_srgb(&raw)
}

fn is_full_page(page: &Page, rect: &Rect) -> bool {
    rect.x == Pt(0) && rect.y == Pt(0) && rect.width == page.width && rect.height == page.height
}

fn opaque_srgb_hex(color: &str) -> Option<String> {
    let [r, g, b, a] = parse_hex_rgba(color)?;
    if a < 255 {
        return None;
    }
    Some(format!("{r:02X}{g:02X}{b:02X}"))
}

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))
}

/// Unfilled native table cells show the slide through. PowerPoint Dark Mode
/// remaps that the same way Word remaps `noFill` cells. Paint the paper/card
/// behind the table (or the slide fill) so lock RGB stays as designed.
fn assign_table_cell_underlays(elements: &mut [SlideElement], paper_hex: &str) {
    let shapes: Vec<(usize, i64, i64, i64, i64, String)> = elements
        .iter()
        .enumerate()
        .filter_map(|(i, el)| match el {
            SlideElement::Shape(s) => s
                .fill_hex
                .as_ref()
                .map(|h| (i, s.x_emu, s.y_emu, s.cx_emu, s.cy_emu, h.clone())),
            _ => None,
        })
        .collect();
    for (i, el) in elements.iter_mut().enumerate() {
        let SlideElement::Table(tbl) = el else {
            continue;
        };
        let px = tbl.x_emu.saturating_add(tbl.cx_emu / 2);
        let py = tbl.y_emu.saturating_add(tbl.cy_emu / 2);
        let mut found = None;
        for (si, x, y, w, h, hex) in &shapes {
            if *si >= i {
                continue;
            }
            if px >= *x && py >= *y && px < x.saturating_add(*w) && py < y.saturating_add(*h) {
                found = Some(hex.clone());
            }
        }
        let paper = crate::text::pin_office_srgb(found.as_deref().unwrap_or(paper_hex));
        for row in &mut tbl.rows {
            for cell in &mut row.cells {
                match &cell.fill_hex {
                    None => cell.fill_hex = Some(paper.clone()),
                    Some(hex) => cell.fill_hex = Some(crate::text::pin_office_srgb(hex)),
                }
            }
        }
    }
}