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.

8.3 KB
Raw Blame
//! What an edit changed: the slides (and slide masters and layouts) whose
//! rendering differs between two states of a presentation, and the caches
//! an undo can carry over.

use super::{EditResult, guides, sections};
use crate::model::masters::{MasterPage, list_pages};
use crate::model::presentation::{PartRef, Presentation};
use crate::model::shape::shows_master_shapes;
use crate::opc::{Relationships, TargetMode, rel_type, rels_part_name};
use crate::xml::{Ns, XmlDoc};
use std::sync::Arc;

/// Parsed XML of a part in state `p` (cached, else parsed from its bytes).
fn doc_of(p: &Presentation, part: &str) -> Option<Arc<XmlDoc>> {
    p.xml.get(part).cloned().or_else(|| {
        let bytes = p.pkg.read(part).ok()?;
        XmlDoc::parse(&bytes, part).ok().map(Arc::new)
    })
}

/// Relationships of a part in state `p` (cached, else parsed).
fn rels_of(p: &Presentation, part: &str) -> Option<Arc<Relationships>> {
    p.rels
        .get(part)
        .cloned()
        .or_else(|| p.pkg.rels(part).ok().map(Arc::new))
}

/// A part of state `p` by (possibly non-canonical) name.
fn part_of(p: &Presentation, name: &str) -> Option<PartRef> {
    let name = p.pkg.canonical_name(name)?.to_owned();
    Some(PartRef {
        doc: doc_of(p, &name)?,
        rels: rels_of(p, &name)?,
        name,
    })
}

/// The target of a part's first relationship of `kind`.
fn related(p: &Presentation, part: &str, kind: &str) -> Option<String> {
    let rels = rels_of(p, part)?;
    let target = rels.first_of_type(kind).map(|r| rels.resolve(r))?;
    p.pkg.canonical_name(&target).map(str::to_owned)
}

/// How Slide Master view lists a master or layout: its name, and whether
/// it hides the master's background graphics.
type Listing = (String, bool);

/// The masters and layouts of state `p`, as Slide Master view lists them.
fn master_list(p: &Presentation) -> Vec<(MasterPage, Listing)> {
    let Some(main) = part_of(p, &p.main_part) else {
        return Vec::new();
    };
    list_pages(&main, &mut |name| part_of(p, name))
        .into_iter()
        .map(|page| {
            let doc = doc_of(p, &page.part);
            let own = doc
                .as_ref()
                .and_then(|d| {
                    d.child(d.root(), Ns::P, "cSld")
                        .and_then(|c| d.attr(c, "name"))
                })
                .unwrap_or("")
                .to_owned();
            let theme = || {
                let theme = related(p, &page.part, rel_type::THEME)?;
                let doc = doc_of(p, &theme)?;
                doc.attr(doc.root(), "name").map(str::to_owned)
            };
            let name = if page.is_layout || !own.trim().is_empty() {
                own
            } else {
                theme().unwrap_or_default()
            };
            let hides = doc.is_some_and(|d| !shows_master_shapes(&d));
            (page, (name, hides))
        })
        .collect()
}

/// Which slides (and masters and layouts) differ between two states of the
/// same presentation.
pub(crate) fn diff(before: &Presentation, after: &Presentation) -> EditResult {
    let ids = |p: &Presentation| p.slides.iter().map(|s| s.id).collect::<Vec<_>>();
    let same = |name: &str| before.pkg.part_identity(name) == after.pkg.part_identity(name);
    let same_with_rels = |name: &str| same(name) && same(&rels_part_name(name));
    // The slide size and numbering show on every slide.
    let deck_changed =
        before.size != after.size || before.first_slide_number != after.first_slide_number;
    let sections_changed =
        !same(&after.main_part) && sections::snapshot(before) != sections::snapshot(after);
    // Guides live in the presentation part (or, in older files, the view
    // properties) and show on every slide.
    let guides_changed = (!same(&after.main_part)
        || after
            .pkg
            .part_names()
            .any(|n| n.ends_with("/viewProps.xml") && !same(n)))
        && guides::snapshot(before) != guides::snapshot(after);
    // Themes, masters, and layouts are drawn under the slides that use them.
    let shared = |name: &str| {
        name.starts_with("/ppt/theme/")
            || name.starts_with("/ppt/slideMasters/")
            || name.starts_with("/ppt/slideLayouts/")
    };
    let shared_changed = after
        .pkg
        .part_names()
        .chain(before.pkg.part_names())
        .any(|name| shared(name) && !same(name));
    // Slide Master view lists masters and layouts by name and options.
    let (masters_before, masters_after) = if shared_changed || !same(&after.main_part) {
        (master_list(before), master_list(after))
    } else {
        (Vec::new(), Vec::new())
    };
    let masters_changed = masters_before
        .iter()
        .map(|(p, n)| (p.id, &p.part, n))
        .ne(masters_after.iter().map(|(p, n)| (p.id, &p.part, n)));
    let structure_changed = ids(before) != ids(after)
        || deck_changed
        || sections_changed
        || guides_changed
        || masters_changed;
    let notes_part = |p: &Presentation, slide: &str| {
        p.rels
            .get(slide)
            .and_then(|r| r.first_of_type(rel_type::NOTES_SLIDE).map(|n| r.resolve(n)))
    };
    // Charts, comments, and SmartArt live in parts of their own; editing one
    // changes the slide.
    let charts_unchanged = |slide: &str| {
        let Some(rels) = rels_of(after, slide) else {
            return true;
        };
        rels.iter()
            .filter(|r| {
                (r.rel_type == rel_type::CHART
                    || r.rel_type.ends_with("/comments")
                    || r.rel_type.contains("/diagram"))
                    && r.mode == TargetMode::Internal
            })
            .all(|r| same(&rels.resolve(r)))
    };
    // A master, with its theme, as drawn under its layouts and slides.
    let master_unchanged = |master: &str| {
        same_with_rels(master)
            && related(after, master, rel_type::THEME).is_none_or(|theme| same(&theme))
    };
    // What a slide inherits: its layout, the layout's master, and its theme.
    let inherited_unchanged = |slide: &str| {
        if !shared_changed {
            return true;
        }
        let Some(layout) = related(after, slide, rel_type::SLIDE_LAYOUT) else {
            return false;
        };
        same_with_rels(&layout)
            && related(after, &layout, rel_type::SLIDE_MASTER).is_some_and(|m| master_unchanged(&m))
    };
    let slides = after.slides.iter().filter(|s| {
        let unchanged = !deck_changed
            && before
                .slides
                .iter()
                .any(|o| o.id == s.id && o.part == s.part)
            && same_with_rels(&s.part)
            && notes_part(after, &s.part).is_none_or(|n| same(&n))
            && charts_unchanged(&s.part)
            && inherited_unchanged(&s.part);
        !unchanged
    });
    let pages = masters_after.iter().filter(|(page, _)| {
        let unchanged = !deck_changed
            && masters_before
                .iter()
                .any(|(o, _)| o.id == page.id && o.part == page.part)
            && master_unchanged(&page.master_part)
            && same_with_rels(&page.part)
            && charts_unchanged(&page.part);
        !unchanged
    });
    EditResult {
        created: Vec::new(),
        changed_slides: slides.map(|s| s.id).collect(),
        changed_layouts: pages.map(|(page, _)| page.id).collect(),
        structure_changed,
        replaced: 0,
    }
}

/// Moves parsed-part and decoded-image caches from `from` into `to` for every
/// part whose bytes are identical in both states.
pub(super) fn carry_caches(from: &Presentation, to: &mut Presentation) {
    let same = |name: &str| from.pkg.part_identity(name) == to.pkg.part_identity(name);
    for (name, doc) in &from.xml {
        if !to.xml.contains_key(name) && same(name) {
            to.xml.insert(name.clone(), doc.clone());
        }
    }
    for (name, rels) in &from.rels {
        if !to.rels.contains_key(name) && same(&rels_part_name(name)) {
            to.rels.insert(name.clone(), rels.clone());
        }
    }
    for (name, img) in &from.images {
        if !to.images.contains_key(name) && same(name) {
            to.images.insert(name.clone(), img.clone());
        }
    }
    for (name, mf) in &from.metafiles {
        if !to.metafiles.contains_key(name) && same(name) {
            to.metafiles.insert(name.clone(), mf.clone());
        }
    }
}