Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

17.6 KB
Raw Blame
//! Slide operations: add from a layout, duplicate, delete, move, hide, and
//! set the background. Sections and custom shows are kept consistent.

use super::ops::FillSpec;
use super::parts::copy_part_tree;
use super::shapes::fill_element;
use super::text;
use super::xmlutil::esc;
use crate::error::{Error, Result};
use crate::model::presentation::Presentation;
use crate::model::shape::{c_nv_pr, placeholder_of, sp_tree, tree_children};
use crate::opc::{Relationships, TargetMode, content_type, rel_type};
use crate::xml::{NodeId, Ns, STANDARD_DECLARATION, XmlDoc};
use serde::Serialize;
use std::collections::HashMap;

/// Child order of `p:presentation`.
pub const PRESENTATION_ORDER: &[&str] = &[
    "sldMasterIdLst",
    "notesMasterIdLst",
    "handoutMasterIdLst",
    "sldIdLst",
    "sldSz",
    "notesSz",
    "smartTags",
    "embeddedFontLst",
    "custShowLst",
    "photoAlbum",
    "custDataLst",
    "kinsoku",
    "defaultTextStyle",
    "modifyVerifier",
    "extLst",
];

/// Namespace declarations for parts the engine writes from scratch.
pub const PML_NAMESPACES: &str = "xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\" xmlns:p=\"http://schemas.openxmlformats.org/presentationml/2006/main\"";

/// The empty group properties every shape tree starts with.
pub const TREE_HEADER: &str = "<p:nvGrpSpPr><p:cNvPr id=\"1\" name=\"\"/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr><p:grpSpPr><a:xfrm><a:off x=\"0\" y=\"0\"/><a:ext cx=\"0\" cy=\"0\"/><a:chOff x=\"0\" y=\"0\"/><a:chExt cx=\"0\" cy=\"0\"/></a:xfrm></p:grpSpPr>";

/// A slide layout new slides can use.
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LayoutInfo {
    /// Layout part name.
    pub part: String,
    /// Display name (`p:cSld/@name`).
    pub name: String,
    /// Layout type (`title`, `obj`, `twoObj`, `titleOnly`, `blank`, `cust`...).
    pub kind: String,
    /// The master it belongs to.
    pub master: String,
}

fn targets_of(doc: &XmlDoc, list: Option<NodeId>, item: &str, rels: &Relationships) -> Vec<String> {
    list.map(|l| {
        doc.children_named(l, Ns::P, item)
            .filter_map(|x| doc.attr_ns(x, Ns::R, "id"))
            .filter_map(|rid| rels.target_part(rid))
            .collect()
    })
    .unwrap_or_default()
}

/// Every layout of every master, in master order.
pub fn layouts(pres: &mut Presentation) -> Result<Vec<LayoutInfo>> {
    let main_name = pres.main_part.clone();
    let main = pres.part(&main_name)?;
    let masters = targets_of(
        &main.doc,
        main.doc.child(main.doc.root(), Ns::P, "sldMasterIdLst"),
        "sldMasterId",
        &main.rels,
    );
    let mut out = Vec::new();
    for m in masters {
        let Ok(master) = pres.part(&m) else { continue };
        let list = master.doc.child(master.doc.root(), Ns::P, "sldLayoutIdLst");
        for lp in targets_of(&master.doc, list, "sldLayoutId", &master.rels) {
            let Ok(layout) = pres.part(&lp) else { continue };
            let d = &layout.doc;
            let name = d
                .child(d.root(), Ns::P, "cSld")
                .and_then(|c| d.attr(c, "name"))
                .unwrap_or("")
                .to_owned();
            let kind = d.attr(d.root(), "type").unwrap_or("cust").to_owned();
            out.push(LayoutInfo {
                part: layout.name.clone(),
                name,
                kind,
                master: master.name.clone(),
            });
        }
    }
    Ok(out)
}

/// The layout part of a slide part.
pub fn layout_of(pres: &mut Presentation, slide_part: &str) -> Option<String> {
    let rels = pres.part_rels(slide_part).ok()?;
    let rel = rels.first_of_type(rel_type::SLIDE_LAYOUT)?;
    let target = rels.resolve(rel);
    pres.pkg.canonical_name(&target).map(str::to_owned)
}

/// The layout part named `name` (preferring the master of slide `after`, or
/// of the last slide), or the layout a new slide after `after` would get.
pub(super) fn find_layout(
    pres: &mut Presentation,
    name: Option<&str>,
    after: Option<u32>,
) -> Result<String> {
    let all = layouts(pres)?;
    if all.is_empty() {
        return Err(Error::InvalidEdit(
            "the presentation has no slide layouts".into(),
        ));
    }
    let reference = after
        .and_then(|id| pres.slide_part(id).ok())
        .or_else(|| pres.slides.last().map(|s| s.part.clone()));
    let ref_layout = reference.and_then(|p| layout_of(pres, &p));
    let ref_master = ref_layout
        .as_ref()
        .and_then(|l| all.iter().find(|x| &x.part == l))
        .map(|x| x.master.clone());
    let same_master = |l: &&LayoutInfo| ref_master.as_ref().is_none_or(|m| &l.master == m);
    if let Some(n) = name.map(str::trim).filter(|n| !n.is_empty()) {
        return all
            .iter()
            .filter(same_master)
            .find(|l| l.name.eq_ignore_ascii_case(n))
            .or_else(|| all.iter().find(|l| l.name.eq_ignore_ascii_case(n)))
            .or_else(|| {
                all.iter()
                    .filter(same_master)
                    .find(|l| l.kind.eq_ignore_ascii_case(n))
            })
            .or_else(|| all.iter().find(|l| l.kind.eq_ignore_ascii_case(n)))
            .map(|l| l.part.clone())
            .ok_or_else(|| {
                let names: Vec<&str> = all.iter().map(|l| l.name.as_str()).collect();
                Error::InvalidEdit(format!(
                    "no layout named `{n}` (available: {})",
                    names.join(", ")
                ))
            });
    }
    // Like PowerPoint's "New Slide": reuse the current layout, except after a title slide.
    if let Some(l) = &ref_layout
        && all
            .iter()
            .find(|x| &x.part == l)
            .is_some_and(|i| i.kind != "title")
    {
        return Ok(l.clone());
    }
    Ok(all
        .iter()
        .filter(same_master)
        .find(|l| l.kind == "obj")
        .or_else(|| all.iter().find(|l| same_master(l)))
        .unwrap_or(&all[0])
        .part
        .clone())
}

/// Placeholder types whose slide copies start with an empty text body.
fn has_text_body(kind: &str) -> bool {
    matches!(kind, "title" | "ctrTitle" | "subTitle" | "body" | "obj")
}

/// Markup of an empty slide placeholder for the layout placeholder `node`
/// (`None` for footers, dates, slide numbers, and non-placeholders).
pub(super) fn placeholder_xml(layout: &XmlDoc, node: NodeId, id: u32) -> Option<String> {
    let ph = placeholder_of(layout, node)?;
    if matches!(ph.kind.as_str(), "dt" | "ftr" | "sldNum" | "hdr") {
        return None;
    }
    let ph_el = layout
        .children(node)
        .find(|&c| layout.local(c).starts_with("nv"))
        .and_then(|nv| layout.child(nv, Ns::P, "nvPr"))
        .and_then(|nv| layout.child(nv, Ns::P, "ph"))?;
    let attrs: String = ["type", "orient", "sz", "idx"]
        .iter()
        .filter_map(|a| {
            layout
                .attr(ph_el, a)
                .map(|v| format!(" {a}=\"{}\"", esc(v)))
        })
        .collect();
    let name = c_nv_pr(layout, node)
        .and_then(|c| layout.attr(c, "name"))
        .unwrap_or("Placeholder");
    let locks = if ph.kind == "pic" {
        "<a:spLocks noGrp=\"1\" noChangeAspect=\"1\"/>"
    } else {
        "<a:spLocks noGrp=\"1\"/>"
    };
    let body = if has_text_body(&ph.kind) {
        "<p:txBody><a:bodyPr/><a:lstStyle/><a:p><a:endParaRPr lang=\"en-US\" dirty=\"0\"/></a:p></p:txBody>"
    } else {
        ""
    };
    Some(format!(
        "<p:sp><p:nvSpPr><p:cNvPr id=\"{id}\" name=\"{}\"/><p:cNvSpPr>{locks}</p:cNvSpPr><p:nvPr><p:ph{attrs}/></p:nvPr></p:nvSpPr><p:spPr/>{body}</p:sp>",
        esc(name)
    ))
}

/// Markup of a new slide carrying the layout's content placeholders.
fn slide_from_layout(layout: &XmlDoc) -> String {
    let mut shapes = String::new();
    let mut id = 2;
    if let Some(tree) = sp_tree(layout) {
        for node in tree_children(layout, tree) {
            let Some(xml) = placeholder_xml(layout, node, id) else {
                continue;
            };
            shapes.push_str(&xml);
            id += 1;
        }
    }
    format!(
        "{STANDARD_DECLARATION}<p:sld {PML_NAMESPACES}><p:cSld><p:spTree>{TREE_HEADER}{shapes}</p:spTree></p:cSld><p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr></p:sld>"
    )
}

/// The placeholder shape of a slide whose type matches `kinds`.
fn placeholder_node(doc: &XmlDoc, kinds: &[&str]) -> Option<NodeId> {
    let tree = sp_tree(doc)?;
    tree_children(doc, tree).into_iter().find(|&n| {
        doc.local(n) == "sp"
            && placeholder_of(doc, n).is_some_and(|p| kinds.contains(&p.kind.as_str()))
    })
}

/// Adds a slide from a layout; returns its id.
pub fn add_slide(
    pres: &mut Presentation,
    layout: Option<&str>,
    after: Option<u32>,
    title: Option<&str>,
    body: Option<&str>,
) -> Result<u32> {
    if let Some(a) = after {
        pres.slide_part(a)?;
    }
    let layout_part = find_layout(pres, layout, after)?;
    let reference = after.or_else(|| pres.slides.last().map(|s| s.id));
    let layout_doc = pres.xml(&layout_part)?;
    let xml = slide_from_layout(&layout_doc);
    let part = pres.pkg.unique_part_name("/ppt/slides/slide", ".xml");
    pres.pkg
        .write(&part, xml.into_bytes(), Some(content_type::SLIDE));
    let mut rels = Relationships::empty(&part);
    rels.add_internal(rel_type::SLIDE_LAYOUT, &layout_part);
    pres.put_rels(rels);
    let id = register_slide(pres, &part, after)?;
    let layout_name = layout_doc
        .child(layout_doc.root(), Ns::P, "cSld")
        .and_then(|c| layout_doc.attr(c, "name"))
        .unwrap_or("")
        .to_owned();
    let doc = pres.xml_mut(&part)?;
    for (value, kinds, what) in [
        (title, &["title", "ctrTitle"][..], "title"),
        (body, &["body", "obj", "subTitle"][..], "body"),
    ] {
        let Some(value) = value else { continue };
        let node = placeholder_node(doc, kinds).ok_or_else(|| {
            Error::InvalidEdit(format!(
                "layout `{layout_name}` has no {what} placeholder; add a text box instead"
            ))
        })?;
        let tx = super::shapes::ensure_tx_body(doc, node)?;
        text::set_text(doc, tx, value)?;
    }
    super::header_footer::follow_masters(pres, id, reference)?;
    Ok(id)
}

/// Adds a slide part to the slide list after `after` (or at the end); returns its id.
pub(super) fn register_slide(
    pres: &mut Presentation,
    part: &str,
    after: Option<u32>,
) -> Result<u32> {
    let main = pres.main_part.clone();
    let rid = pres.rels_mut(&main)?.add_internal(rel_type::SLIDE, part);
    let random = pres.pkg.ids().cloned();
    let doc = pres.xml_mut(&main)?;
    let root = doc.root();
    let list = doc.ensure_child(root, Ns::P, "sldIdLst", PRESENTATION_ORDER);
    let ids: Vec<i64> = doc
        .children_named(list, Ns::P, "sldId")
        .filter_map(|s| doc.attr_i64(s, "id"))
        .collect();
    let id = match random {
        Some(random) => loop {
            let id = random.next_in(256..2_147_483_648) as i64;
            if !ids.contains(&id) {
                break id;
            }
        },
        None => ids.iter().copied().max().unwrap_or(255).max(255) + 1,
    };
    let id = if id < 2_147_483_648 {
        id
    } else {
        (256..2_147_483_648)
            .find(|c| !ids.contains(c))
            .ok_or_else(|| Error::LimitExceeded("slide ids".into()))?
    };
    let el = doc.create_element(Ns::P, "sldId");
    doc.set_attr(el, "id", &id.to_string());
    doc.set_attr_ns(el, Ns::R, "id", &rid);
    let previous = after.and_then(|a| {
        doc.children_named(list, Ns::P, "sldId")
            .find(|&s| doc.attr_i64(s, "id") == Some(i64::from(a)))
    });
    match previous {
        Some(p) => doc.insert_after(p, el),
        None => doc.append_child(list, el),
    }
    super::sections::place(doc, id);
    pres.reload_structure()?;
    Ok(id as u32)
}

/// Duplicates a slide (with its notes, charts, and diagrams) right after itself.
pub fn duplicate_slide(pres: &mut Presentation, id: u32) -> Result<u32> {
    let part = pres.slide_part(id)?;
    let mut renamed = HashMap::new();
    let new = copy_part_tree(pres, &part, &mut renamed)?;
    drop_creation_id(pres.xml_mut(&new)?);
    register_slide(pres, &new, Some(id))
}

/// Removes a copied slide's creation id, which identifies the original
/// slide for co-authoring, and the reference to the original's comments
/// (which are not copied).
pub(super) fn drop_creation_id(doc: &mut XmlDoc) {
    if let Some(ext_lst) = doc.child(doc.root(), Ns::P, "extLst") {
        let doomed: Vec<NodeId> = doc
            .children(ext_lst)
            .filter(|&e| {
                doc.descendants(e)
                    .iter()
                    .any(|&n| doc.local(n) == "creationId")
                    || super::comments::is_comment_rel_ext(doc, e)
            })
            .collect();
        for d in doomed {
            doc.detach(d);
        }
    }
}

/// Deletes a slide, its private parts, and links pointing at it.
pub fn delete_slide(pres: &mut Presentation, id: u32) -> Result<()> {
    let part = pres.slide_part(id)?;
    let rid = pres
        .slides
        .iter()
        .find(|s| s.id == id)
        .map(|s| s.rid.clone())
        .unwrap_or_default();
    let main = pres.main_part.clone();
    {
        let doc = pres.xml_mut(&main)?;
        let root = doc.root();
        if let Some(list) = doc.child(root, Ns::P, "sldIdLst") {
            let doomed: Vec<NodeId> = doc
                .children_named(list, Ns::P, "sldId")
                .filter(|&s| doc.attr_i64(s, "id") == Some(i64::from(id)))
                .collect();
            for d in doomed {
                doc.detach(d);
            }
        }
        super::sections::remove(doc, i64::from(id));
        if let Some(shows) = doc.child(root, Ns::P, "custShowLst") {
            let doomed: Vec<NodeId> = doc
                .descendants(shows)
                .into_iter()
                .filter(|&n| {
                    doc.local(n) == "sld" && doc.attr_ns(n, Ns::R, "id") == Some(rid.as_str())
                })
                .collect();
            for d in doomed {
                doc.detach(d);
            }
        }
    }
    pres.rels_mut(&main)?.remove(&rid);
    // Hyperlinks from other slides that jump to the deleted one.
    let others: Vec<String> = pres
        .slides
        .iter()
        .filter(|s| s.id != id)
        .map(|s| s.part.clone())
        .collect();
    for other in others {
        let rels = pres.part_rels(&other)?;
        let doomed: Vec<String> = rels
            .iter()
            .filter(|r| r.mode == TargetMode::Internal && r.rel_type == rel_type::SLIDE)
            .filter(|r| rels.resolve(r).eq_ignore_ascii_case(&part))
            .map(|r| r.id.clone())
            .collect();
        if doomed.is_empty() {
            continue;
        }
        let doc = pres.xml_mut(&other)?;
        let links: Vec<NodeId> = doc
            .descendants(doc.root())
            .into_iter()
            .filter(|&n| matches!(doc.local(n), "hlinkClick" | "hlinkMouseOver"))
            .filter(|&n| {
                doc.attr_ns(n, Ns::R, "id")
                    .is_some_and(|r| doomed.iter().any(|d| d == r))
            })
            .collect();
        for l in links {
            doc.detach(l);
        }
        let rels = pres.rels_mut(&other)?;
        for d in &doomed {
            rels.remove(d);
        }
    }
    pres.reload_structure()
}

/// Moves a slide to a 0-based position.
pub fn move_slide(pres: &mut Presentation, id: u32, to: usize) -> Result<()> {
    pres.slide_part(id)?;
    let main = pres.main_part.clone();
    let doc = pres.xml_mut(&main)?;
    let list = doc
        .child(doc.root(), Ns::P, "sldIdLst")
        .ok_or_else(|| Error::NotFound(format!("slide {id}")))?;
    let items: Vec<NodeId> = doc.children_named(list, Ns::P, "sldId").collect();
    let node = items
        .iter()
        .copied()
        .find(|&s| doc.attr_i64(s, "id") == Some(i64::from(id)))
        .ok_or_else(|| Error::NotFound(format!("slide {id}")))?;
    let others: Vec<NodeId> = items.into_iter().filter(|&s| s != node).collect();
    doc.detach(node);
    match others.get(to.min(others.len())) {
        Some(&before) => doc.insert_before(before, node),
        None => match others.last() {
            Some(&last) => doc.insert_after(last, node),
            None => doc.append_child(list, node),
        },
    }
    super::sections::place(doc, i64::from(id));
    pres.reload_structure()
}

/// Hides or shows a slide during slideshows.
pub fn set_hidden(pres: &mut Presentation, id: u32, hidden: bool) -> Result<()> {
    let part = pres.slide_part(id)?;
    let doc = pres.xml_mut(&part)?;
    let root = doc.root();
    if hidden {
        doc.set_attr(root, "show", "0");
    } else {
        doc.remove_attr(root, "show");
    }
    Ok(())
}

/// Sets (or removes, inheriting the layout's) a slide background; a slide
/// master's or layout's id sets its own background.
pub fn set_background(pres: &mut Presentation, id: u32, fill: Option<&FillSpec>) -> Result<()> {
    let part = pres.page_part(id)?;
    let doc = pres.xml_mut(&part)?;
    let c_sld = doc
        .child(doc.root(), Ns::P, "cSld")
        .ok_or_else(|| Error::InvalidEdit("slide has no cSld".into()))?;
    doc.remove_children_named(c_sld, Ns::P, "bg");
    if let Some(spec) = fill {
        let bg = doc.create_element(Ns::P, "bg");
        let pr = doc.create_element(Ns::P, "bgPr");
        let f = fill_element(doc, spec)?;
        doc.append_child(pr, f);
        let fx = doc.create_element(Ns::A, "effectLst");
        doc.append_child(pr, fx);
        doc.append_child(bg, pr);
        doc.insert_child(c_sld, 0, bg);
    }
    Ok(())
}