1use serde::{Deserialize, Serialize};
6
7use crate::namespaces;
8
9#[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#[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#[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#[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
108pub const SLICER_DRAWING_2010_NS: &str = "http://schemas.microsoft.com/office/drawing/2010/slicer";
110
111pub 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#[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#[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#[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#[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#[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#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
239pub struct CNvGraphicFramePr {}
240
241#[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#[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#[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#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
273pub struct Graphic {
274 #[serde(rename = "a:graphicData")]
275 pub graphic_data: GraphicData,
276}
277
278#[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#[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#[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#[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#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
323pub struct CNvPicPr {}
324
325#[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#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
337pub struct Blip {
338 #[serde(rename = "@r:embed")]
339 pub r_embed: String,
340}
341
342#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
344pub struct Stretch {
345 #[serde(rename = "a:fillRect")]
346 pub fill_rect: FillRect,
347}
348
349#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
351pub struct FillRect {}
352
353#[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#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
365pub struct PrstGeom {
366 #[serde(rename = "@prst")]
367 pub prst: String,
368}
369
370#[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#[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#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
395pub struct CNvSpPr {}
396
397#[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#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
415pub struct SolidFill {
416 #[serde(rename = "a:srgbClr")]
417 pub srgb_clr: SrgbClr,
418}
419
420#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
422pub struct SrgbClr {
423 #[serde(rename = "@val")]
424 pub val: String,
425}
426
427#[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#[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#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
452pub struct BodyPr {}
453
454#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
456pub struct LstStyle {}
457
458#[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#[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#[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#[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}