pptx 0.1.0

A Rust library for creating and manipulating PowerPoint (.pptx) files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Data types for slide, layout, master, and notes references.

use crate::enums::shapes::PpPlaceholderType;
use crate::opc::pack_uri::PackURI;
use crate::shapes::shapetree::ShapeTree;
use crate::shapes::Shape;
use crate::text::TextFrame;
use crate::units::{RelationshipId, SlideId};

/// A reference to a slide within a presentation.
///
/// This is a lightweight handle that stores the slide's partname and relationship ID.
/// Actual slide content (the XML blob) is accessed through the [`OpcPackage`](crate::opc::OpcPackage).
#[derive(Debug, Clone)]
pub struct SlideRef {
    /// The rId linking this slide from the presentation part.
    pub r_id: RelationshipId,
    /// Absolute partname of the slide part.
    pub partname: PackURI,
}

/// A reference to a slide layout within the package.
#[derive(Debug, Clone)]
pub struct SlideLayoutRef {
    /// The rId linking this layout from its slide master.
    pub r_id: RelationshipId,
    /// Absolute partname of the slide layout part.
    pub partname: PackURI,
    /// The layout name from the XML (e.g. "Title Slide", "Title and Content").
    pub name: String,
    /// Absolute partname of the parent slide master, if resolved.
    pub slide_master_part_name: Option<String>,
}

/// A reference to a slide master within the package.
#[derive(Debug, Clone)]
pub struct SlideMasterRef {
    /// The rId linking this master from the presentation part.
    pub r_id: RelationshipId,
    /// Absolute partname of the slide master part.
    pub partname: PackURI,
}

/// A reference to a notes slide within the package.
#[derive(Debug, Clone)]
pub struct NotesSlideRef {
    /// Absolute partname of the notes slide part.
    pub partname: PackURI,
}

/// A reference to the notes master within the package.
#[derive(Debug, Clone)]
pub struct NotesMasterRef {
    /// The rId linking this notes master from the presentation part.
    pub r_id: RelationshipId,
    /// Absolute partname of the notes master part.
    pub partname: PackURI,
}

/// Properties of a slide.
#[derive(Debug, Clone)]
pub struct SlideProperties {
    /// The numeric slide ID from the presentation XML.
    pub slide_id: SlideId,
    /// The optional name from the `<p:cSld name="...">` element.
    pub name: String,
    /// Whether this slide has an associated notes slide.
    pub has_notes_slide: bool,
}

/// A parsed notes slide with its shapes and text content.
///
/// Provides access to the notes slide's shape tree, placeholder shapes,
/// and the notes text body.
#[derive(Debug, Clone)]
pub struct NotesSlide {
    /// The optional name from the `<p:cSld name="...">` element.
    pub name: Option<String>,
    /// All shapes parsed from the notes slide's shape tree.
    pub shapes: ShapeTree,
    /// The plain text content of the notes body placeholder.
    pub notes_text: String,
    /// The part name (URI) of this notes slide within the package.
    pub part_name: Option<String>,
}

impl NotesSlide {
    /// Get the optional name of the notes slide.
    #[must_use]
    pub fn name(&self) -> Option<&str> {
        self.name.as_deref()
    }

    /// Get the part name (URI) of this notes slide within the package.
    #[must_use]
    pub fn part_name(&self) -> Option<&str> {
        self.part_name.as_deref()
    }

    /// Get the shape tree containing all shapes on this notes slide.
    #[must_use]
    pub const fn shapes(&self) -> &ShapeTree {
        &self.shapes
    }

    /// Get all placeholder shapes on this notes slide.
    #[must_use]
    pub fn placeholders(&self) -> Vec<&Shape> {
        self.shapes
            .shapes
            .iter()
            .filter(|s| s.is_placeholder())
            .collect()
    }

    /// Find the notes body placeholder (typically `type="body"` with `idx=1`).
    #[must_use]
    pub fn notes_placeholder(&self) -> Option<&Shape> {
        self.shapes.shapes.iter().find(|s| {
            s.placeholder()
                .is_some_and(|ph| ph.ph_type == Some(PpPlaceholderType::Body))
        })
    }

    /// Get the `TextFrame` from the notes body placeholder, if it is an `AutoShape`.
    #[must_use]
    pub fn notes_text_frame(&self) -> Option<&TextFrame> {
        self.notes_placeholder()
            .and_then(|s| s.as_autoshape())
            .and_then(|a| a.text_frame())
    }

    /// Get the plain text content of the notes.
    #[must_use]
    pub fn notes_text(&self) -> &str {
        &self.notes_text
    }
}