rust-office-art 0.1.4

Shared Office picture, shape, connector and saved SmartArt rendering for Rust and WebAssembly
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

use crate::xml::{direct_child_tag, escape_xml_text, extract_balanced_tag_slices};
use crate::{PictureContext, RenderedPicture};
use quick_xml::{events::Event, Reader};

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Model3DAsset {
    pub part_name: String,
    pub content_type: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub data: Option<serde_bytes::ByteBuf>,
}

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Model3D {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub model_relationship_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub linked_model_relationship_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub asset: Option<Model3DAsset>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub preview: Option<Model3DPreview>,
    pub source_xml: String,
}

pub fn model3d_xml(xml: &str) -> Option<&str> {
    if xml.len() > 4 * 1024 * 1024 || !xml.contains("model3d") {
        return None;
    }
    let mut reader = Reader::from_str(xml);
    loop {
        let start = reader.buffer_position() as usize;
        match reader.read_event().ok()? {
            Event::Start(tag) if tag.local_name().as_ref() == b"model3d" => {
                reader.read_to_end(tag.name()).ok()?;
                let model = &xml[start..reader.buffer_position() as usize];
                return (model.len() <= 256 * 1024).then_some(model);
            }
            Event::Empty(tag) if tag.local_name().as_ref() == b"model3d" => {
                let model = &xml[start..reader.buffer_position() as usize];
                return (model.len() <= 256 * 1024).then_some(model);
            }
            Event::Eof => return None,
            _ => {}
        }
    }
}

fn attribute(xml: &str, name: &[u8]) -> Option<String> {
    let mut reader = Reader::from_str(xml);
    let (Event::Start(tag) | Event::Empty(tag)) = reader.read_event().ok()? else {
        return None;
    };
    tag.attributes().filter_map(Result::ok).find_map(|attr| {
        (attr.key.local_name().as_ref() == name)
            .then(|| {
                attr.decode_and_unescape_value(reader.decoder())
                    .ok()
                    .map(|value| value.into_owned())
            })
            .flatten()
    })
}

fn child<'a>(xml: &'a str, name: &str) -> Option<&'a str> {
    let tag = crate::xml::extract_direct_child_tag_ranges(xml)
        .into_iter()
        .find(|tag| tag.tag_name.rsplit(':').next() == Some(name))?;
    Some(&xml[tag.start..tag.end])
}

pub fn parse_model3d(
    xml: &str,
    options: &crate::ParseOptions,
    mut resolve_asset: impl FnMut(&str) -> Option<Model3DAsset>,
) -> Option<Model3D> {
    if !options.include_3d_models {
        return None;
    }
    let model = model3d_xml(xml)?;
    let model_relationship_id = attribute(model, b"embed");
    Some(Model3D {
        asset: model_relationship_id
            .as_deref()
            .and_then(&mut resolve_asset),
        model_relationship_id,
        linked_model_relationship_id: attribute(model, b"link"),
        preview: parse_model3d_preview(model),
        source_xml: model.to_owned(),
    })
}

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Model3DPreview {
    pub model_relationship_id: Option<String>,
    pub raster_relationship_id: String,
    pub renderer: Option<String>,
    pub renderer_version: Option<String>,
}

pub fn parse_model3d_preview(xml: &str) -> Option<Model3DPreview> {
    let model = model3d_xml(xml)?;
    let raster = child(model, "raster")?;
    let blip = child(raster, "blip")?;
    Some(Model3DPreview {
        model_relationship_id: attribute(model, b"embed"),
        raster_relationship_id: attribute(blip, b"embed")?,
        renderer: attribute(raster, b"rName"),
        renderer_version: attribute(raster, b"rVer"),
    })
}

pub fn render_model3d_preview(
    xml: &str,
    source: &str,
    width: f64,
    height: f64,
    context: &impl PictureContext,
) -> Option<RenderedPicture> {
    let preview = parse_model3d_preview(xml)?;
    let model = extract_balanced_tag_slices(xml, "am3d:model3d")
        .into_iter()
        .next()?;
    let properties = direct_child_tag(model, "am3d:spPr")?
        .replacen("am3d:spPr", "pic:spPr", 1)
        .replace("</am3d:spPr>", "</pic:spPr>");
    let picture = format!(
        r#"<pic:pic><pic:blipFill><a:blip r:embed="{}"/><a:stretch><a:fillRect/></a:stretch></pic:blipFill>{properties}</pic:pic>"#,
        escape_xml_text(&preview.raster_relationship_id),
    );
    crate::render_picture(&picture, source, width, height, context)
}