Skip to main content

sheetkit_xml/
drawing.rs

1//! DrawingML Spreadsheet Drawing XML schema structures.
2//!
3//! Represents `xl/drawings/drawing{N}.xml` in the OOXML package.
4
5use serde::{Deserialize, Serialize};
6
7use crate::namespaces;
8
9/// Root element for a spreadsheet drawing part.
10#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11#[serde(rename = "wsDr")]
12pub struct WsDr {
13    #[serde(rename = "@xmlns:xdr", default = "default_spreadsheet_drawing_ns")]
14    pub xmlns_xdr: String,
15
16    #[serde(rename = "@xmlns:a", default = "default_drawing_ml_ns")]
17    pub xmlns_a: String,
18
19    #[serde(rename = "@xmlns:r", default = "crate::default_relationships_ns")]
20    pub xmlns_r: String,
21
22    #[serde(rename = "xdr:twoCellAnchor", default)]
23    pub two_cell_anchors: Vec<TwoCellAnchor>,
24
25    #[serde(rename = "xdr:oneCellAnchor", default)]
26    pub one_cell_anchors: Vec<OneCellAnchor>,
27}
28
29impl Default for WsDr {
30    fn default() -> Self {
31        Self {
32            xmlns_xdr: namespaces::DRAWING_ML_SPREADSHEET.to_string(),
33            xmlns_a: namespaces::DRAWING_ML.to_string(),
34            xmlns_r: namespaces::RELATIONSHIPS.to_string(),
35            two_cell_anchors: vec![],
36            one_cell_anchors: vec![],
37        }
38    }
39}
40
41/// An anchor defined by two cell markers (from/to).
42#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
43pub struct TwoCellAnchor {
44    #[serde(rename = "xdr:from")]
45    pub from: MarkerType,
46
47    #[serde(rename = "xdr:to")]
48    pub to: MarkerType,
49
50    #[serde(rename = "xdr:graphicFrame", skip_serializing_if = "Option::is_none")]
51    pub graphic_frame: Option<GraphicFrame>,
52
53    #[serde(rename = "xdr:pic", skip_serializing_if = "Option::is_none")]
54    pub pic: Option<Picture>,
55
56    #[serde(rename = "xdr:sp", skip_serializing_if = "Option::is_none")]
57    pub shape: Option<Shape>,
58
59    #[serde(rename = "xdr:clientData")]
60    pub client_data: ClientData,
61}
62
63/// An anchor defined by one cell marker and an extent.
64#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
65pub struct OneCellAnchor {
66    #[serde(rename = "xdr:from")]
67    pub from: MarkerType,
68
69    #[serde(rename = "xdr:ext")]
70    pub ext: Extent,
71
72    #[serde(rename = "xdr:pic", skip_serializing_if = "Option::is_none")]
73    pub pic: Option<Picture>,
74
75    #[serde(
76        rename = "mc:AlternateContent",
77        skip_serializing_if = "Option::is_none"
78    )]
79    pub alternate_content: Option<SlicerAlternateContent>,
80
81    #[serde(rename = "xdr:clientData")]
82    pub client_data: ClientData,
83}
84
85#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
86pub struct SlicerAlternateContent {
87    #[serde(rename = "@xmlns:mc")]
88    pub xmlns_mc: String,
89    #[serde(rename = "mc:Choice")]
90    pub choice: SlicerChoice,
91    #[serde(rename = "mc:Fallback")]
92    pub fallback: SlicerFallback,
93}
94
95/// The `mc:Choice` branch of a slicer anchor.
96///
97/// Serialization declares each known prefix named in `Requires` (`sle`,
98/// `sle15`) on the `mc:Choice` element itself, because Markup Compatibility
99/// requires those prefixes to be in scope where `Requires` is evaluated.
100#[derive(Debug, Clone, PartialEq, Deserialize)]
101pub struct SlicerChoice {
102    #[serde(rename = "@Requires")]
103    pub requires: String,
104    #[serde(rename = "xdr:graphicFrame")]
105    pub graphic_frame: SlicerGraphicFrame,
106}
107
108/// Namespace URI bound to the `sle` prefix (Office 2010 slicer drawing).
109pub const SLICER_DRAWING_2010_NS: &str = "http://schemas.microsoft.com/office/drawing/2010/slicer";
110
111/// Namespace URI bound to the `sle15` prefix (Office 2013 table slicer drawing).
112pub const SLICER_DRAWING_2012_NS: &str = "http://schemas.microsoft.com/office/drawing/2012/slicer";
113
114impl Serialize for SlicerChoice {
115    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
116        #[derive(Serialize)]
117        struct Repr<'a> {
118            #[serde(rename = "@Requires")]
119            requires: &'a str,
120            #[serde(rename = "@xmlns:sle", skip_serializing_if = "Option::is_none")]
121            xmlns_sle: Option<&'static str>,
122            #[serde(rename = "@xmlns:sle15", skip_serializing_if = "Option::is_none")]
123            xmlns_sle15: Option<&'static str>,
124            #[serde(rename = "xdr:graphicFrame")]
125            graphic_frame: &'a SlicerGraphicFrame,
126        }
127        let requires = |prefix: &str| self.requires.split_whitespace().any(|p| p == prefix);
128        Repr {
129            xmlns_sle: requires("sle").then_some(SLICER_DRAWING_2010_NS),
130            xmlns_sle15: requires("sle15").then_some(SLICER_DRAWING_2012_NS),
131            requires: &self.requires,
132            graphic_frame: &self.graphic_frame,
133        }
134        .serialize(serializer)
135    }
136}
137
138#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
139pub struct SlicerGraphicFrame {
140    #[serde(rename = "@macro", skip_serializing_if = "Option::is_none")]
141    pub macro_name: Option<String>,
142    #[serde(rename = "xdr:nvGraphicFramePr")]
143    pub nv_graphic_frame_pr: NvGraphicFramePr,
144    #[serde(rename = "xdr:xfrm")]
145    pub xfrm: Xfrm,
146    #[serde(rename = "a:graphic")]
147    pub graphic: SlicerGraphic,
148}
149
150#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
151pub struct SlicerGraphic {
152    #[serde(rename = "a:graphicData")]
153    pub graphic_data: SlicerGraphicData,
154}
155
156#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
157pub struct SlicerGraphicData {
158    #[serde(rename = "@uri")]
159    pub uri: String,
160    #[serde(rename = "@xmlns:sle")]
161    pub xmlns_sle: String,
162    #[serde(rename = "sle:slicer")]
163    pub slicer: SlicerRef,
164}
165
166#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
167pub struct SlicerRef {
168    #[serde(rename = "@name")]
169    pub name: String,
170}
171
172#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
173pub struct SlicerFallback {
174    #[serde(rename = "xdr:sp")]
175    pub shape: Shape,
176}
177
178/// A cell marker indicating column, column offset, row, and row offset.
179#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
180pub struct MarkerType {
181    #[serde(rename = "xdr:col")]
182    pub col: u32,
183
184    #[serde(rename = "xdr:colOff")]
185    pub col_off: u64,
186
187    #[serde(rename = "xdr:row")]
188    pub row: u32,
189
190    #[serde(rename = "xdr:rowOff")]
191    pub row_off: u64,
192}
193
194/// Extent (size) in EMU (English Metric Units).
195#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
196pub struct Extent {
197    #[serde(rename = "@cx")]
198    pub cx: u64,
199
200    #[serde(rename = "@cy")]
201    pub cy: u64,
202}
203
204/// Graphic frame containing a chart reference.
205#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
206pub struct GraphicFrame {
207    #[serde(rename = "xdr:nvGraphicFramePr")]
208    pub nv_graphic_frame_pr: NvGraphicFramePr,
209
210    #[serde(rename = "xdr:xfrm")]
211    pub xfrm: Xfrm,
212
213    #[serde(rename = "a:graphic")]
214    pub graphic: Graphic,
215}
216
217/// Non-visual graphic frame properties.
218#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
219pub struct NvGraphicFramePr {
220    #[serde(rename = "xdr:cNvPr")]
221    pub c_nv_pr: CNvPr,
222
223    #[serde(rename = "xdr:cNvGraphicFramePr")]
224    pub c_nv_graphic_frame_pr: CNvGraphicFramePr,
225}
226
227/// Common non-visual properties (id and name).
228#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
229pub struct CNvPr {
230    #[serde(rename = "@id")]
231    pub id: u32,
232
233    #[serde(rename = "@name")]
234    pub name: String,
235}
236
237/// Non-visual graphic frame properties (empty marker).
238#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
239pub struct CNvGraphicFramePr {}
240
241/// Transform (position and size) for a graphic frame.
242#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
243pub struct Xfrm {
244    #[serde(rename = "a:off")]
245    pub off: Offset,
246
247    #[serde(rename = "a:ext")]
248    pub ext: AExt,
249}
250
251/// Offset position.
252#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
253pub struct Offset {
254    #[serde(rename = "@x")]
255    pub x: i64,
256
257    #[serde(rename = "@y")]
258    pub y: i64,
259}
260
261/// DrawingML extent (width/height).
262#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
263pub struct AExt {
264    #[serde(rename = "@cx")]
265    pub cx: u64,
266
267    #[serde(rename = "@cy")]
268    pub cy: u64,
269}
270
271/// Graphic element containing chart data.
272#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
273pub struct Graphic {
274    #[serde(rename = "a:graphicData")]
275    pub graphic_data: GraphicData,
276}
277
278/// Graphic data referencing a chart.
279#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
280pub struct GraphicData {
281    #[serde(rename = "@uri")]
282    pub uri: String,
283
284    #[serde(rename = "c:chart")]
285    pub chart: ChartRef,
286}
287
288/// Reference to a chart part via relationship ID.
289#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
290pub struct ChartRef {
291    #[serde(rename = "@xmlns:c")]
292    pub xmlns_c: String,
293
294    #[serde(rename = "@r:id")]
295    pub r_id: String,
296}
297
298/// Picture element for images.
299#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
300pub struct Picture {
301    #[serde(rename = "xdr:nvPicPr")]
302    pub nv_pic_pr: NvPicPr,
303
304    #[serde(rename = "xdr:blipFill")]
305    pub blip_fill: BlipFill,
306
307    #[serde(rename = "xdr:spPr")]
308    pub sp_pr: SpPr,
309}
310
311/// Non-visual picture properties.
312#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
313pub struct NvPicPr {
314    #[serde(rename = "xdr:cNvPr")]
315    pub c_nv_pr: CNvPr,
316
317    #[serde(rename = "xdr:cNvPicPr")]
318    pub c_nv_pic_pr: CNvPicPr,
319}
320
321/// Non-visual picture-specific properties (empty marker).
322#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
323pub struct CNvPicPr {}
324
325/// Blip fill referencing an embedded image.
326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
327pub struct BlipFill {
328    #[serde(rename = "a:blip")]
329    pub blip: Blip,
330
331    #[serde(rename = "a:stretch")]
332    pub stretch: Stretch,
333}
334
335/// Blip (Binary Large Image or Picture) reference.
336#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
337pub struct Blip {
338    #[serde(rename = "@r:embed")]
339    pub r_embed: String,
340}
341
342/// Stretch fill mode.
343#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
344pub struct Stretch {
345    #[serde(rename = "a:fillRect")]
346    pub fill_rect: FillRect,
347}
348
349/// Fill rectangle (empty element indicating full fill).
350#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
351pub struct FillRect {}
352
353/// Shape properties for a picture.
354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
355pub struct SpPr {
356    #[serde(rename = "a:xfrm")]
357    pub xfrm: Xfrm,
358
359    #[serde(rename = "a:prstGeom")]
360    pub prst_geom: PrstGeom,
361}
362
363/// Preset geometry (e.g., rectangle).
364#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
365pub struct PrstGeom {
366    #[serde(rename = "@prst")]
367    pub prst: String,
368}
369
370/// Shape element (`<xdr:sp>`).
371#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
372pub struct Shape {
373    #[serde(rename = "xdr:nvSpPr")]
374    pub nv_sp_pr: NvSpPr,
375
376    #[serde(rename = "xdr:spPr")]
377    pub sp_pr: ShapeSpPr,
378
379    #[serde(rename = "xdr:txBody", skip_serializing_if = "Option::is_none")]
380    pub tx_body: Option<TxBody>,
381}
382
383/// Non-visual shape properties.
384#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
385pub struct NvSpPr {
386    #[serde(rename = "xdr:cNvPr")]
387    pub c_nv_pr: CNvPr,
388
389    #[serde(rename = "xdr:cNvSpPr")]
390    pub c_nv_sp_pr: CNvSpPr,
391}
392
393/// Non-visual shape-specific properties (empty marker).
394#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
395pub struct CNvSpPr {}
396
397/// Shape properties with optional fill and line.
398#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
399pub struct ShapeSpPr {
400    #[serde(rename = "a:xfrm")]
401    pub xfrm: Xfrm,
402
403    #[serde(rename = "a:prstGeom")]
404    pub prst_geom: PrstGeom,
405
406    #[serde(rename = "a:solidFill", skip_serializing_if = "Option::is_none")]
407    pub solid_fill: Option<SolidFill>,
408
409    #[serde(rename = "a:ln", skip_serializing_if = "Option::is_none")]
410    pub ln: Option<Ln>,
411}
412
413/// Solid fill with an sRGB color.
414#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
415pub struct SolidFill {
416    #[serde(rename = "a:srgbClr")]
417    pub srgb_clr: SrgbClr,
418}
419
420/// sRGB color value.
421#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
422pub struct SrgbClr {
423    #[serde(rename = "@val")]
424    pub val: String,
425}
426
427/// Line properties.
428#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
429pub struct Ln {
430    #[serde(rename = "@w", skip_serializing_if = "Option::is_none")]
431    pub w: Option<u64>,
432
433    #[serde(rename = "a:solidFill", skip_serializing_if = "Option::is_none")]
434    pub solid_fill: Option<SolidFill>,
435}
436
437/// Text body element.
438#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
439pub struct TxBody {
440    #[serde(rename = "a:bodyPr")]
441    pub body_pr: BodyPr,
442
443    #[serde(rename = "a:lstStyle")]
444    pub lst_style: LstStyle,
445
446    #[serde(rename = "a:p")]
447    pub paragraphs: Vec<Paragraph>,
448}
449
450/// Body properties for text (empty marker with optional attributes).
451#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
452pub struct BodyPr {}
453
454/// List style for text (empty marker).
455#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
456pub struct LstStyle {}
457
458/// A text paragraph.
459#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
460pub struct Paragraph {
461    #[serde(rename = "a:r", default, skip_serializing_if = "Vec::is_empty")]
462    pub runs: Vec<TextRun>,
463}
464
465/// A text run within a paragraph.
466#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
467pub struct TextRun {
468    #[serde(rename = "a:rPr", skip_serializing_if = "Option::is_none")]
469    pub r_pr: Option<RunProperties>,
470
471    #[serde(rename = "a:t")]
472    pub t: String,
473}
474
475/// Run-level text properties.
476#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
477pub struct RunProperties {
478    #[serde(rename = "@lang", skip_serializing_if = "Option::is_none")]
479    pub lang: Option<String>,
480
481    #[serde(rename = "@sz", skip_serializing_if = "Option::is_none")]
482    pub sz: Option<u32>,
483}
484
485/// Client data (empty element required by spec).
486#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
487pub struct ClientData {}
488
489fn default_spreadsheet_drawing_ns() -> String {
490    namespaces::DRAWING_ML_SPREADSHEET.to_string()
491}
492
493fn default_drawing_ml_ns() -> String {
494    namespaces::DRAWING_ML.to_string()
495}
496
497#[cfg(test)]
498mod tests {
499    use super::*;
500
501    #[test]
502    fn test_ws_dr_default() {
503        let dr = WsDr::default();
504        assert_eq!(dr.xmlns_xdr, namespaces::DRAWING_ML_SPREADSHEET);
505        assert_eq!(dr.xmlns_a, namespaces::DRAWING_ML);
506        assert_eq!(dr.xmlns_r, namespaces::RELATIONSHIPS);
507        assert!(dr.two_cell_anchors.is_empty());
508        assert!(dr.one_cell_anchors.is_empty());
509    }
510
511    #[test]
512    fn test_marker_type_serialize() {
513        let marker = MarkerType {
514            col: 1,
515            col_off: 0,
516            row: 2,
517            row_off: 0,
518        };
519        let xml = quick_xml::se::to_string(&marker).unwrap();
520        assert!(xml.contains("<xdr:col>1</xdr:col>"));
521        assert!(xml.contains("<xdr:row>2</xdr:row>"));
522    }
523
524    #[test]
525    fn test_extent_serialize() {
526        let ext = Extent {
527            cx: 9525000,
528            cy: 4762500,
529        };
530        let xml = quick_xml::se::to_string(&ext).unwrap();
531        assert!(xml.contains("cx=\"9525000\""));
532        assert!(xml.contains("cy=\"4762500\""));
533    }
534
535    #[test]
536    fn test_chart_ref_serialize() {
537        let chart_ref = ChartRef {
538            xmlns_c: namespaces::DRAWING_ML_CHART.to_string(),
539            r_id: "rId1".to_string(),
540        };
541        let xml = quick_xml::se::to_string(&chart_ref).unwrap();
542        assert!(xml.contains("r:id=\"rId1\""));
543    }
544
545    #[test]
546    fn test_blip_serialize() {
547        let blip = Blip {
548            r_embed: "rId2".to_string(),
549        };
550        let xml = quick_xml::se::to_string(&blip).unwrap();
551        assert!(xml.contains("r:embed=\"rId2\""));
552    }
553
554    #[test]
555    fn test_prst_geom_serialize() {
556        let geom = PrstGeom {
557            prst: "rect".to_string(),
558        };
559        let xml = quick_xml::se::to_string(&geom).unwrap();
560        assert!(xml.contains("prst=\"rect\""));
561    }
562}