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.

15.7 KB
Raw Blame
//! The presentation document: package, parsed-part caches, and the slide list.

use super::color::ColorMap;
use super::field::FieldTime;
use super::theme::Theme;
use crate::error::{Error, Result};
use crate::opc::{Package, Relationships, rel_type};
use crate::xml::{Ns, XmlDoc};
use std::collections::{BTreeSet, HashMap};
use std::sync::Arc;

/// A parsed part: name, XML, and relationships.
#[derive(Clone, Debug)]
pub struct PartRef {
    /// Part name.
    pub name: String,
    /// Parsed XML.
    pub doc: Arc<XmlDoc>,
    /// The part's relationships.
    pub rels: Arc<Relationships>,
}

impl PartRef {
    /// Resolves an internal relationship id to a part name.
    pub fn target(&self, rid: &str) -> Option<String> {
        self.rels.target_part(rid)
    }
}

/// One entry of the slide list.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SlideEntry {
    /// Stable slide id (`p:sldId/@id`).
    pub id: u32,
    /// Relationship id from the presentation part.
    pub rid: String,
    /// Slide part name.
    pub part: String,
}

/// Everything needed to resolve inheritance for one slide.
#[derive(Clone, Debug)]
pub struct SlideContext {
    /// The slide (or layout/master when rendering those directly).
    pub slide: PartRef,
    /// Its layout.
    pub layout: Option<PartRef>,
    /// Its master.
    pub master: Option<PartRef>,
    /// The presentation part (default text style).
    pub presentation: PartRef,
    /// Effective theme.
    pub theme: Arc<Theme>,
    /// Effective color map.
    pub color_map: ColorMap,
    /// The number slide-number fields show (the deck's first slide number
    /// plus the 0-based position).
    pub number: usize,
    /// Slide size in EMU.
    pub size: (i64, i64),
    /// The time automatic date fields show (`None`: their cached text).
    pub clock: Option<FieldTime>,
}

/// A presentation opened for rendering and editing.
#[derive(Clone)]
pub struct Presentation {
    pub(crate) pkg: Package,
    pub(crate) main_part: String,
    pub(crate) xml: HashMap<String, Arc<XmlDoc>>,
    pub(crate) rels: HashMap<String, Arc<Relationships>>,
    themes: HashMap<String, Arc<Theme>>,
    pub(crate) slides: Vec<SlideEntry>,
    /// Slide size in EMU.
    pub(crate) size: (i64, i64),
    /// The number of the first slide (`p:presentation/@firstSlideNum`).
    pub(crate) first_slide_number: u32,
    /// The time automatic date fields show; `None` renders their cached text.
    pub(crate) clock: Option<FieldTime>,
    /// Decoded pictures by part name (`None` = undecodable).
    pub(crate) images: HashMap<String, Option<Arc<crate::render::scene::Raster>>>,
    /// Parsed metafiles by part name (`None` = unparseable).
    pub(crate) metafiles: HashMap<String, Option<Arc<crate::render::metafile::Metafile>>>,
    /// Parts whose cached XML was edited and must be written back to the package.
    pub(crate) dirty_xml: BTreeSet<String>,
    /// Parts whose cached relationships were edited.
    pub(crate) dirty_rels: BTreeSet<String>,
    /// The shared maps of a collaborative presentation.
    pub(crate) collab: Option<Arc<crate::collab::Mirror>>,
}

/// Default slide size (16:9, 13.333 × 7.5 in).
pub const DEFAULT_SLIDE_SIZE: (i64, i64) = (12_192_000, 6_858_000);
/// The slide side range ECMA-376 allows (1 to 56 inches, in EMU).
const MIN_SLIDE_SIDE: i64 = 914_400;
const MAX_SLIDE_SIDE: i64 = 51_206_400;

impl Presentation {
    /// Opens a `.pptx` file.
    pub fn open(bytes: Vec<u8>) -> Result<Self> {
        let pkg = Package::open(bytes)?;
        let main_part = pkg.main_part()?;
        let mut p = Self {
            pkg,
            main_part,
            xml: HashMap::new(),
            rels: HashMap::new(),
            themes: HashMap::new(),
            slides: Vec::new(),
            size: DEFAULT_SLIDE_SIZE,
            first_slide_number: 1,
            clock: None,
            images: HashMap::new(),
            metafiles: HashMap::new(),
            dirty_xml: BTreeSet::new(),
            dirty_rels: BTreeSet::new(),
            collab: None,
        };
        p.reload_structure()?;
        Ok(p)
    }

    /// Re-reads the slide list and slide size from the presentation part.
    pub(crate) fn reload_structure(&mut self) -> Result<()> {
        let main = self.part(&self.main_part.clone())?;
        let doc = &main.doc;
        let root = doc.root();
        if let Some(sz) = doc.child(root, Ns::P, "sldSz") {
            let cx = doc.attr_i64(sz, "cx").unwrap_or(DEFAULT_SLIDE_SIZE.0);
            let cy = doc.attr_i64(sz, "cy").unwrap_or(DEFAULT_SLIDE_SIZE.1);
            if cx > 0 && cy > 0 {
                self.size = (
                    cx.clamp(MIN_SLIDE_SIDE, MAX_SLIDE_SIDE),
                    cy.clamp(MIN_SLIDE_SIDE, MAX_SLIDE_SIDE),
                );
            }
        }
        self.first_slide_number = doc
            .attr_i64(root, "firstSlideNum")
            .and_then(|n| u32::try_from(n).ok())
            .unwrap_or(1);
        self.slides.clear();
        if let Some(list) = doc.child(root, Ns::P, "sldIdLst") {
            for s in doc.children_named(list, Ns::P, "sldId") {
                let (Some(id), Some(rid)) = (doc.attr_i64(s, "id"), doc.attr_ns(s, Ns::R, "id"))
                else {
                    continue;
                };
                let Some(part) = main.target(rid) else {
                    continue;
                };
                if !self.pkg.has_part(&part) {
                    continue;
                }
                let part = self.pkg.canonical_name(&part).unwrap_or(&part).to_owned();
                self.slides.push(SlideEntry {
                    id: id as u32,
                    rid: rid.to_owned(),
                    part,
                });
            }
        }
        Ok(())
    }

    /// The underlying package.
    pub fn package(&self) -> &Package {
        &self.pkg
    }

    /// Name of the main presentation part.
    pub fn main_part_name(&self) -> &str {
        &self.main_part
    }

    /// Slide size in EMU.
    pub fn slide_size(&self) -> (i64, i64) {
        self.size
    }

    /// The slide list.
    pub fn slides(&self) -> &[SlideEntry] {
        &self.slides
    }

    /// The number the slide at `index` (0-based) shows in slide-number fields.
    pub fn slide_number(&self, index: usize) -> usize {
        self.first_slide_number as usize + index
    }

    /// Sets the time automatic date fields show when slides are rendered and
    /// written; `None` (the default) renders the text cached in the file.
    pub fn set_clock(&mut self, now: Option<FieldTime>) {
        self.clock = now;
    }

    /// The time new automatic date fields are written with: the clock, or
    /// (natively) the current UTC time.
    pub(crate) fn field_time(&self) -> Option<FieldTime> {
        #[cfg(not(target_arch = "wasm32"))]
        return self.clock.or_else(|| Some(FieldTime::now_utc()));
        #[cfg(target_arch = "wasm32")]
        return self.clock;
    }

    /// Parsed XML of a part (cached).
    pub fn xml(&mut self, part: &str) -> Result<Arc<XmlDoc>> {
        let name = self
            .pkg
            .canonical_name(part)
            .map(str::to_owned)
            .unwrap_or_else(|| part.to_owned());
        if let Some(doc) = self.xml.get(&name) {
            return Ok(Arc::clone(doc));
        }
        let bytes = self.pkg.read(&name)?;
        let doc = Arc::new(XmlDoc::parse(&bytes, &name)?);
        self.xml.insert(name, Arc::clone(&doc));
        Ok(doc)
    }

    /// Relationships of a part (cached).
    pub fn part_rels(&mut self, part: &str) -> Result<Arc<Relationships>> {
        if let Some(r) = self.rels.get(part) {
            return Ok(Arc::clone(r));
        }
        let r = Arc::new(self.pkg.rels(part)?);
        self.rels.insert(part.to_owned(), Arc::clone(&r));
        Ok(r)
    }

    /// A part with its XML and relationships.
    pub fn part(&mut self, name: &str) -> Result<PartRef> {
        let canonical = self
            .pkg
            .canonical_name(name)
            .map(str::to_owned)
            .unwrap_or_else(|| name.to_owned());
        Ok(PartRef {
            doc: self.xml(&canonical)?,
            rels: self.part_rels(&canonical)?,
            name: canonical,
        })
    }

    /// Reads raw bytes of a part.
    pub fn read_bytes(&self, part: &str) -> Result<Vec<u8>> {
        Ok(self.pkg.read(part)?.into_owned())
    }

    /// The theme of a master (or the presentation's first theme).
    pub fn theme_for(&mut self, master: Option<&PartRef>) -> Arc<Theme> {
        let theme_part = master
            .and_then(|m| {
                m.rels
                    .first_of_type(rel_type::THEME)
                    .map(|r| m.rels.resolve(r))
            })
            .or_else(|| {
                let main = self.main_part.clone();
                self.part_rels(&main)
                    .ok()
                    .and_then(|r| r.first_of_type(rel_type::THEME).map(|t| r.resolve(t)))
            });
        let Some(theme_part) = theme_part else {
            return Arc::new(Theme::default());
        };
        if let Some(t) = self.themes.get(&theme_part) {
            return Arc::clone(t);
        }
        let theme = match self.xml(&theme_part) {
            Ok(doc) => {
                let mut theme = Theme::parse(doc);
                if let Ok(rels) = self.part_rels(&theme_part) {
                    theme.rels = rels;
                }
                Arc::new(theme)
            }
            Err(_) => Arc::new(Theme::default()),
        };
        self.themes.insert(theme_part, Arc::clone(&theme));
        theme
    }

    /// The layout and master of a slide part.
    pub fn layout_and_master(&mut self, slide: &PartRef) -> (Option<PartRef>, Option<PartRef>) {
        let layout = slide
            .rels
            .first_of_type(rel_type::SLIDE_LAYOUT)
            .map(|r| slide.rels.resolve(r))
            .and_then(|n| self.part(&n).ok());
        let master_of = |p: &PartRef| {
            p.rels
                .first_of_type(rel_type::SLIDE_MASTER)
                .map(|r| p.rels.resolve(r))
        };
        let master = layout
            .as_ref()
            .and_then(master_of)
            .or_else(|| master_of(slide))
            .and_then(|n| self.part(&n).ok());
        (layout, master)
    }

    /// Builds the inheritance context of slide `index` (0-based).
    pub fn slide_context(&mut self, index: usize) -> Result<SlideContext> {
        let entry = self
            .slides
            .get(index)
            .cloned()
            .ok_or_else(|| Error::NotFound(format!("slide {index}")))?;
        let slide = self.part(&entry.part)?;
        self.context_for(slide, self.slide_number(index))
    }

    /// Builds an inheritance context for any slide-like part (slide, layout, master, notes).
    pub fn context_for(&mut self, slide: PartRef, number: usize) -> Result<SlideContext> {
        let is_master = slide.doc.is(slide.doc.root(), Ns::P, "sldMaster");
        let is_layout = slide.doc.is(slide.doc.root(), Ns::P, "sldLayout");
        let (layout, master) = if is_master {
            (None, None)
        } else if is_layout {
            let master = slide
                .rels
                .first_of_type(rel_type::SLIDE_MASTER)
                .map(|r| slide.rels.resolve(r))
                .and_then(|n| self.part(&n).ok());
            (None, master)
        } else {
            self.layout_and_master(&slide)
        };
        let theme_source = if is_master {
            Some(&slide)
        } else {
            master.as_ref()
        };
        let theme = self.theme_for(theme_source);
        let color_map = effective_color_map(&slide, layout.as_ref(), master.as_ref(), is_master);
        let main = self.main_part.clone();
        let presentation = self.part(&main)?;
        Ok(SlideContext {
            slide,
            layout,
            master,
            presentation,
            theme,
            color_map,
            number,
            size: self.size,
            clock: self.clock,
        })
    }

    /// Mutable XML of a part, marking it for write-back.
    ///
    /// Copy-on-write: snapshots that share the document keep the old version.
    pub(crate) fn xml_mut(&mut self, part: &str) -> Result<&mut XmlDoc> {
        let name = self
            .pkg
            .canonical_name(part)
            .map(str::to_owned)
            .unwrap_or_else(|| part.to_owned());
        self.xml(&name)?;
        self.dirty_xml.insert(name.clone());
        let doc = self
            .xml
            .get_mut(&name)
            .ok_or_else(|| Error::MissingPart(name.clone()))?;
        Ok(Arc::make_mut(doc))
    }

    /// Mutable relationships of a part, marking them for write-back.
    pub(crate) fn rels_mut(&mut self, part: &str) -> Result<&mut Relationships> {
        let name = self
            .pkg
            .canonical_name(part)
            .map(str::to_owned)
            .unwrap_or_else(|| part.to_owned());
        self.part_rels(&name)?;
        self.dirty_rels.insert(name.clone());
        let rels = self
            .rels
            .get_mut(&name)
            .ok_or_else(|| Error::MissingPart(name.clone()))?;
        Ok(Arc::make_mut(rels))
    }

    /// Installs relationships for a (possibly new) part, marking them for write-back.
    pub(crate) fn put_rels(&mut self, rels: Relationships) {
        let rels = rels.with_ids(self.pkg.ids().cloned());
        let name = rels.source().to_owned();
        self.dirty_rels.insert(name.clone());
        self.rels.insert(name, Arc::new(rels));
    }

    /// Drops the parsed view of an edited theme part.
    pub(crate) fn forget_theme(&mut self, part: &str) {
        self.themes.remove(part);
    }

    /// Forgets every cached view of a removed part.
    pub(crate) fn forget(&mut self, part: &str) {
        self.xml.remove(part);
        self.rels.remove(part);
        self.themes.remove(part);
        self.images.remove(part);
        self.metafiles.remove(part);
        self.dirty_xml.remove(part);
        self.dirty_rels.remove(part);
    }

    /// Writes edited XML and relationships back into the package.
    pub(crate) fn flush(&mut self) {
        for name in std::mem::take(&mut self.dirty_xml) {
            if let Some(doc) = self.xml.get(&name) {
                self.pkg.write(&name, doc.to_bytes(), None);
            }
        }
        for name in std::mem::take(&mut self.dirty_rels) {
            if let Some(rels) = self.rels.get(&name) {
                let rels = Arc::clone(rels);
                if rels.iter().next().is_none() && name != "/" {
                    // An empty relationships part is legal but noisy; drop it.
                    self.pkg.delete(&crate::opc::rels_part_name(&name));
                } else {
                    self.pkg.write_rels(&rels);
                }
            }
        }
    }

    /// Serializes the presentation, writing back every edit.
    pub fn save(&mut self) -> Result<Vec<u8>> {
        self.flush();
        self.pkg.save()
    }
}

fn effective_color_map(
    slide: &PartRef,
    layout: Option<&PartRef>,
    master: Option<&PartRef>,
    is_master: bool,
) -> ColorMap {
    let override_of = |p: &PartRef| -> Option<ColorMap> {
        let doc = &p.doc;
        let ovr = doc.child(doc.root(), Ns::P, "clrMapOvr")?;
        let o = doc.child(ovr, Ns::A, "overrideClrMapping")?;
        Some(ColorMap::parse(doc, o))
    };
    if is_master {
        return slide
            .doc
            .child(slide.doc.root(), Ns::P, "clrMap")
            .map(|n| ColorMap::parse(&slide.doc, n))
            .unwrap_or_default();
    }
    if let Some(m) = override_of(slide) {
        return m;
    }
    if let Some(m) = layout.and_then(override_of) {
        return m;
    }
    master
        .and_then(|m| {
            m.doc
                .child(m.doc.root(), Ns::P, "clrMap")
                .map(|n| ColorMap::parse(&m.doc, n))
        })
        .unwrap_or_default()
}