k2f_pptx 0.2.4

K2F lock → PPTX exporter
Documentation
use crate::ir::{ScriptPos, SlideElement, SlideIR, TextBox, TextRun};
use crate::xml::escape_xml;
use std::collections::BTreeMap;

pub(crate) fn textbox_sp_xml(
    tb: &TextBox,
    cnv_id: u32,
    hyperlink_rids: &BTreeMap<String, String>,
) -> String {
    let name = escape_xml(&tb.node_id);
    let body = txbody_inner(
        &tb.runs,
        tb.align,
        tb.bullet,
        tb.numbered,
        tb.preserve_whitespace,
        tb.line_spc_pts,
        tb.last_line_spc_pts,
        tb.mar_l_emu,
        tb.list_start,
        hyperlink_rids,
        "      ",
    );
    let (lins, rins) = (tb.l_ins_emu, tb.r_ins_emu);
    // Host metrics that are wider than rustybuzz wrap an extra line in a
    // lock-tight frame. Clip is the DrawingML default in some hosts.
    let overflow = r#" vertOverflow="overflow" horzOverflow="overflow""#;
    format!(
        r#"    <p:sp>
      <p:nvSpPr>
        <p:cNvPr id="{id}" name="{name}"/>
        <p:cNvSpPr txBox="1"/>
        <p:nvPr/>
      </p:nvSpPr>
      <p:spPr>
        <a:xfrm>
          <a:off x="{x}" y="{y}"/>
          <a:ext cx="{cx}" cy="{cy}"/>
        </a:xfrm>
        <a:prstGeom prst="rect"><a:avLst/></a:prstGeom>
        <a:noFill/>
        <a:ln><a:noFill/></a:ln>
      </p:spPr>
      <p:txBody>
        <a:bodyPr wrap="{wrap}" lIns="{lins}" tIns="{tins}" rIns="{rins}" bIns="0" rtlCol="0" anchor="t"{overflow}>
          <a:noAutofit/>
        </a:bodyPr>
        <a:lstStyle/>
{body}      </p:txBody>
    </p:sp>
"#,
        id = cnv_id,
        x = tb.x_emu,
        y = tb.y_emu,
        cx = tb.cx_emu,
        cy = tb.cy_emu,
        tins = tb.t_ins_emu,
        wrap = if tb.wrap { "square" } else { "none" },
    )
}

pub(crate) fn txbody_inner(
    runs: &[TextRun],
    align: crate::ir::TextAlign,
    bullet: bool,
    numbered: bool,
    preserve: bool,
    line_spc_pts: Option<i32>,
    last_line_spc_pts: Option<i32>,
    mar_l_emu: i64,
    list_start: u32,
    hyperlink_rids: &BTreeMap<String, String>,
    indent: &str,
) -> String {
    let paras = paragraph_runs(runs);
    let mut body = String::new();
    let n = paras.len();
    for (i, para) in paras.iter().enumerate() {
        let list_on = i == 0;
        let spc = if i + 1 == n && n > 1 {
            last_line_spc_pts.or(line_spc_pts)
        } else {
            line_spc_pts
        };
        body.push_str(&paragraph_xml(
            para,
            align,
            list_on && bullet,
            list_on && numbered,
            preserve,
            spc,
            if list_on { mar_l_emu } else { 0 },
            if list_on { list_start } else { 1 },
            hyperlink_rids,
            indent,
        ));
    }
    if paras.is_empty() {
        body.push_str(indent);
        body.push_str("<a:p/>\n");
    }
    body
}

fn paragraph_runs(runs: &[TextRun]) -> Vec<Vec<TextRun>> {
    let mut paras: Vec<Vec<TextRun>> = vec![Vec::new()];
    for run in runs {
        let mut rest = run.text.as_str();
        while let Some(i) = rest.find('\n') {
            let mut head = &rest[..i];
            if let Some(stripped) = head.strip_suffix('\r') {
                head = stripped;
            }
            if !head.is_empty() {
                let mut piece = run.clone();
                piece.text = head.to_string();
                paras.last_mut().unwrap().push(piece);
            }
            paras.push(Vec::new());
            rest = &rest[i + 1..];
        }
        if !rest.is_empty() {
            let mut piece = run.clone();
            piece.text = rest.to_string();
            paras.last_mut().unwrap().push(piece);
        }
    }
    paras
}

fn paragraph_xml(
    runs: &[TextRun],
    align: crate::ir::TextAlign,
    _bullet: bool,
    _numbered: bool,
    preserve: bool,
    line_spc_pts: Option<i32>,
    mar_l_emu: i64,
    _list_start: u32,
    hyperlink_rids: &BTreeMap<String, String>,
    indent: &str,
) -> String {
    let mut p = String::new();
    p.push_str(indent);
    p.push_str("<a:p>\n");
    p.push_str(indent);
    p.push_str("  <a:pPr algn=\"");
    p.push_str(align_token(align));
    p.push_str("\"");
    if mar_l_emu > 0 {
        p.push_str(&format!(r#" marL="{mar_l_emu}" indent="-{mar_l_emu}""#));
    }
    p.push('>');
    if let Some(pts) = line_spc_pts {
        p.push_str(&format!(r#"<a:lnSpc><a:spcPts val="{pts}"/></a:lnSpc>"#));
    }
    // Markers are literal text runs (see prepend_literal_*). Native
    // a:buChar / a:buAutoNum in floating frames often collapse or renumber
    // by host document order.
    p.push_str("<a:buNone/>");
    p.push_str("</a:pPr>\n");
    for run in runs {
        p.push_str(indent);
        p.push_str("  ");
        p.push_str(&run_xml(run, preserve, hyperlink_rids));
    }
    p.push_str(indent);
    p.push_str("</a:p>\n");
    p
}

fn align_token(align: crate::ir::TextAlign) -> &'static str {
    match align {
        crate::ir::TextAlign::Left => "l",
        crate::ir::TextAlign::Center => "ctr",
        crate::ir::TextAlign::Right => "r",
        crate::ir::TextAlign::Justify => "just",
    }
}

fn run_xml(run: &TextRun, preserve_box: bool, hyperlink_rids: &BTreeMap<String, String>) -> String {
    let mut rpr = format!(
        r#"<a:rPr lang="en-US" sz="{sz}" dirty="0""#,
        sz = run.sz_hundredths_pt
    );
    if run.tracking_spc != 0 {
        rpr.push_str(&format!(r#" spc="{}""#, run.tracking_spc));
    }
    if run.bold {
        rpr.push_str(r#" b="1""#);
    }
    if run.italic {
        rpr.push_str(r#" i="1""#);
    }
    if run.underline {
        rpr.push_str(r#" u="sng""#);
    }
    if run.strike {
        rpr.push_str(r#" strike="sngStrike""#);
    }
    match run.script {
        ScriptPos::Super => rpr.push_str(r#" baseline="30000""#),
        ScriptPos::Sub => rpr.push_str(r#" baseline="-25000""#),
        ScriptPos::Baseline => {}
    }
    rpr.push('>');
    rpr.push_str(&format!(
        r#"<a:solidFill><a:srgbClr val="{}"/></a:solidFill>"#,
        run.color_hex
    ));
    let face = escape_xml(&run.font_name);
    rpr.push_str(&format!(
        r#"<a:latin typeface="{face}"/><a:ea typeface="{face}"/><a:cs typeface="{face}"/>"#
    ));
    if let Some(url) = &run.hyperlink {
        if let Some(rid) = hyperlink_rids.get(url) {
            rpr.push_str(&format!(r#"<a:hlinkClick r:id="{rid}"/>"#));
        }
    }
    rpr.push_str("</a:rPr>");
    let preserve = preserve_box
        || run.text.starts_with(char::is_whitespace)
        || run.text.ends_with(char::is_whitespace);
    let space = if preserve {
        r#" xml:space="preserve""#
    } else {
        ""
    };
    format!(
        "<a:r>{rpr}<a:t{space}>{}</a:t></a:r>\n",
        escape_xml(&run.text)
    )
}

pub(crate) fn collect_hyperlink_urls(slide: &SlideIR) -> Vec<String> {
    let mut urls = Vec::new();
    for el in &slide.elements {
        match el {
            SlideElement::TextBox(tb) => push_urls(&tb.runs, &mut urls),
            SlideElement::Table(t) => {
                for row in &t.rows {
                    for cell in &row.cells {
                        push_urls(&cell.runs, &mut urls);
                    }
                }
            }
            SlideElement::Shape(_) | SlideElement::Picture(_) | SlideElement::Raster(_) => {}
        }
    }
    urls
}

fn push_urls(runs: &[TextRun], urls: &mut Vec<String>) {
    for run in runs {
        if let Some(url) = &run.hyperlink {
            if !url.is_empty() && !urls.iter().any(|u| u == url) {
                urls.push(url.clone());
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ir::{ScriptPos, TextAlign, TextRun};

    fn run(text: &str) -> TextRun {
        TextRun {
            text: text.into(),
            font_name: "Times New Roman".into(),
            sz_hundredths_pt: 1200,
            bold: false,
            italic: false,
            underline: false,
            strike: false,
            color_hex: "000001".into(),
            hyperlink: None,
            script: ScriptPos::Baseline,
            tracking_spc: 0,
        }
    }

    #[test]
    fn numbered_paragraph_uses_literal_marker_not_autonum() {
        let xml = paragraph_xml(
            &[run("3.\u{00A0}Dong")],
            TextAlign::Left,
            false,
            true,
            false,
            None,
            200_000,
            3,
            &BTreeMap::new(),
            "",
        );
        assert!(xml.contains("<a:buNone/>"), "{xml}");
        assert!(!xml.contains("buAutoNum"), "{xml}");
        assert!(xml.contains(r#"marL="200000""#), "{xml}");
        assert!(xml.contains(r#"indent="-200000""#), "{xml}");
        assert!(xml.contains(">3."), "{xml}");
    }

    #[test]
    fn body_pr_emits_no_autofit_and_center_algn() {
        let tb = crate::ir::TextBox {
            node_id: "title".into(),
            x_emu: 0,
            y_emu: 0,
            cx_emu: 1_000_000,
            cy_emu: 200_000,
            runs: vec![run("Title")],
            align: TextAlign::Center,
            bullet: false,
            numbered: false,
            preserve_whitespace: false,
            wrap: true,
            line_spc_pts: None,
            last_line_spc_pts: None,
            t_ins_emu: 0,
            l_ins_emu: 0,
            r_ins_emu: 0,
            mar_l_emu: 0,
            list_start: 1,
        };
        let xml = textbox_sp_xml(&tb, 2, &BTreeMap::new());
        assert!(xml.contains("<a:noAutofit/>"), "{xml}");
        assert!(xml.contains(r#"wrap="square""#), "{xml}");
        assert!(xml.contains(r#"algn="ctr""#), "{xml}");
        assert!(xml.contains(r#"vertOverflow="overflow""#), "{xml}");
        assert!(xml.contains(r#"horzOverflow="overflow""#), "{xml}");
    }

    #[test]
    fn last_pinned_paragraph_uses_face_spacing() {
        let mut r1 = run("line one");
        r1.text = "line one\nline two".into();
        let tb = crate::ir::TextBox {
            node_id: "quote".into(),
            x_emu: 0,
            y_emu: 0,
            cx_emu: 1_000_000,
            cy_emu: 200_000,
            runs: vec![r1],
            align: TextAlign::Left,
            bullet: false,
            numbered: false,
            preserve_whitespace: false,
            wrap: false,
            line_spc_pts: Some(1820),
            last_line_spc_pts: Some(1300),
            t_ins_emu: 0,
            l_ins_emu: 0,
            r_ins_emu: 0,
            mar_l_emu: 0,
            list_start: 1,
        };
        let xml = textbox_sp_xml(&tb, 2, &BTreeMap::new());
        assert!(xml.contains(r#"<a:spcPts val="1820"/>"#), "{xml}");
        assert!(xml.contains(r#"<a:spcPts val="1300"/>"#), "{xml}");
        let first = xml.find(r#"<a:spcPts val="1820"/>"#).unwrap();
        let last = xml.find(r#"<a:spcPts val="1300"/>"#).unwrap();
        assert!(first < last, "last para must use face spacing, got {xml}");
    }
}