1use serde::{Deserialize, Serialize};
6
7use super::common::{AttrValInt, AttrValString, RichTextRun, XlsxInnerXml};
8
9#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
15pub struct XlsxCNvPr {
16 #[serde(rename = "@id")]
17 pub id: i64,
18 #[serde(rename = "@name")]
19 pub name: String,
20 #[serde(rename = "@descr")]
21 pub descr: String,
22 #[serde(rename = "@title", default)]
23 pub title: Option<String>,
24 #[serde(rename = "a:hlinkClick", default, alias = "hlinkClick")]
25 pub hlink_click: Option<XlsxHlinkClick>,
26}
27
28#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
30pub struct XlsxHlinkClick {
31 #[serde(rename = "@xmlns:r", default)]
32 pub xmlns_r: Option<String>,
33 #[serde(rename = "@r:id", default)]
34 pub r_id: Option<String>,
35 #[serde(rename = "@invalidUrl", default)]
36 pub invalid_url: Option<String>,
37 #[serde(rename = "@action", default)]
38 pub action: Option<String>,
39 #[serde(rename = "@tgtFrame", default)]
40 pub tgt_frame: Option<String>,
41 #[serde(rename = "@tooltip", default)]
42 pub tooltip: Option<String>,
43 #[serde(rename = "@history", default)]
44 pub history: Option<bool>,
45 #[serde(rename = "@highlightClick", default)]
46 pub highlight_click: Option<bool>,
47 #[serde(rename = "@endSnd", default)]
48 pub end_snd: Option<bool>,
49}
50
51#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
53pub struct XlsxPicLocks {
54 #[serde(
55 rename = "@noAdjustHandles",
56 default,
57 skip_serializing_if = "Option::is_none"
58 )]
59 pub no_adjust_handles: Option<bool>,
60 #[serde(
61 rename = "@noChangeArrowheads",
62 default,
63 skip_serializing_if = "Option::is_none"
64 )]
65 pub no_change_arrowheads: Option<bool>,
66 #[serde(rename = "@noChangeAspect")]
67 pub no_change_aspect: bool,
68 #[serde(
69 rename = "@noChangeShapeType",
70 default,
71 skip_serializing_if = "Option::is_none"
72 )]
73 pub no_change_shape_type: Option<bool>,
74 #[serde(rename = "@noCrop", default, skip_serializing_if = "Option::is_none")]
75 pub no_crop: Option<bool>,
76 #[serde(
77 rename = "@noEditPoints",
78 default,
79 skip_serializing_if = "Option::is_none"
80 )]
81 pub no_edit_points: Option<bool>,
82 #[serde(rename = "@noGrp", default, skip_serializing_if = "Option::is_none")]
83 pub no_grp: Option<bool>,
84 #[serde(rename = "@noMove", default, skip_serializing_if = "Option::is_none")]
85 pub no_move: Option<bool>,
86 #[serde(rename = "@noResize", default, skip_serializing_if = "Option::is_none")]
87 pub no_resize: Option<bool>,
88 #[serde(rename = "@noRot", default, skip_serializing_if = "Option::is_none")]
89 pub no_rot: Option<bool>,
90 #[serde(rename = "@noSelect", default, skip_serializing_if = "Option::is_none")]
91 pub no_select: Option<bool>,
92}
93
94#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
100pub struct XlsxBlip {
101 #[serde(rename = "@r:embed")]
102 pub embed: String,
103 #[serde(rename = "@cstate", default)]
104 pub cstate: Option<String>,
105 #[serde(rename = "@xmlns:r")]
106 pub xmlns_r: String,
107 #[serde(rename = "a:extLst", default)]
108 pub ext_list: Option<XlsxEGOfficeArtExtensionList>,
109}
110
111#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
113pub struct XlsxStretch {
114 #[serde(rename = "a:fillRect", default)]
115 pub fill_rect: String,
116}
117
118#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
120pub struct XlsxCTSVGBlip {
121 #[serde(rename = "@xmlns:asvg")]
122 pub xmlns_asvg: String,
123 #[serde(rename = "@r:embed")]
124 pub embed: String,
125 #[serde(rename = "@r:link", default)]
126 pub link: Option<String>,
127}
128
129#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
131#[serde(rename = "a:ext")]
132pub struct XlsxCTOfficeArtExtension {
133 #[serde(rename = "@uri")]
134 pub uri: String,
135 #[serde(rename = "asvg:svgBlip")]
136 pub svg_blip: XlsxCTSVGBlip,
137}
138
139#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
141pub struct XlsxEGOfficeArtExtensionList {
142 #[serde(rename = "a:ext", default)]
143 pub ext: Vec<XlsxCTOfficeArtExtension>,
144}
145
146#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
148pub struct XlsxBlipFill {
149 #[serde(rename = "a:blip")]
150 pub blip: XlsxBlip,
151 #[serde(rename = "a:stretch")]
152 pub stretch: XlsxStretch,
153}
154
155#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
161pub struct XlsxOff {
162 #[serde(rename = "@x")]
163 pub x: i64,
164 #[serde(rename = "@y")]
165 pub y: i64,
166}
167
168#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
170pub struct XlsxPositiveSize2D {
171 #[serde(rename = "@cx")]
172 pub cx: i64,
173 #[serde(rename = "@cy")]
174 pub cy: i64,
175}
176
177#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
179pub struct XlsxPrstGeom {
180 #[serde(rename = "@prst")]
181 pub prst: String,
182}
183
184#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
186pub struct XlsxXfrm {
187 #[serde(rename = "a:off", alias = "off")]
188 pub off: XlsxOff,
189 #[serde(rename = "a:ext", alias = "ext")]
190 pub ext: XlsxPositiveSize2D,
191}
192
193#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
198pub struct XlsxCNvPicPr {
199 #[serde(rename = "a:picLocks")]
200 pub pic_locks: XlsxPicLocks,
201}
202
203#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
204pub struct XlsxNvPicPr {
205 #[serde(rename = "xdr:cNvPr")]
206 pub c_nv_pr: XlsxCNvPr,
207 #[serde(rename = "xdr:cNvPicPr")]
208 pub c_nv_pic_pr: XlsxCNvPicPr,
209}
210
211#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
217pub struct AScrgbClr {
218 #[serde(rename = "@r")]
219 pub r: f64,
220 #[serde(rename = "@g")]
221 pub g: f64,
222 #[serde(rename = "@b")]
223 pub b: f64,
224}
225
226#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
228pub struct ASchemeClr {
229 #[serde(rename = "@val", default)]
230 pub val: Option<String>,
231 #[serde(rename = "a:lumMod", default)]
232 pub lum_mod: Option<AttrValInt>,
233 #[serde(rename = "a:lumOff", default)]
234 pub lum_off: Option<AttrValInt>,
235}
236
237#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
239pub struct ASrgbClr {
240 #[serde(rename = "@val", default)]
241 pub val: Option<String>,
242 #[serde(rename = "a:tint", default)]
243 pub tint: Option<AttrValInt>,
244 #[serde(rename = "a:shade", default)]
245 pub shade: Option<AttrValInt>,
246 #[serde(rename = "a:comp", default)]
247 pub comp: Option<AttrValInt>,
248 #[serde(rename = "a:inv", default)]
249 pub inv: Option<AttrValInt>,
250 #[serde(rename = "a:gray", default)]
251 pub gray: Option<AttrValInt>,
252 #[serde(rename = "a:alpha", default)]
253 pub alpha: Option<AttrValInt>,
254 #[serde(rename = "a:alphaOff", default)]
255 pub alpha_off: Option<AttrValInt>,
256 #[serde(rename = "a:alphaMod", default)]
257 pub alpha_mod: Option<AttrValInt>,
258 #[serde(rename = "a:hue", default)]
259 pub hue: Option<AttrValInt>,
260 #[serde(rename = "a:hueOff", default)]
261 pub hue_off: Option<AttrValInt>,
262 #[serde(rename = "a:hueMod", default)]
263 pub hue_mod: Option<AttrValInt>,
264 #[serde(rename = "a:sat", default)]
265 pub sat: Option<AttrValInt>,
266 #[serde(rename = "a:satOff", default)]
267 pub sat_off: Option<AttrValInt>,
268 #[serde(rename = "a:satMod", default)]
269 pub sat_mod: Option<AttrValInt>,
270 #[serde(rename = "a:lum", default)]
271 pub lum: Option<AttrValInt>,
272 #[serde(rename = "a:lumOff", default)]
273 pub lum_off: Option<AttrValInt>,
274 #[serde(rename = "a:lumMod", default)]
275 pub lum_mod: Option<AttrValInt>,
276 #[serde(rename = "a:red", default)]
277 pub red: Option<AttrValInt>,
278 #[serde(rename = "a:redOff", default)]
279 pub red_off: Option<AttrValInt>,
280 #[serde(rename = "a:redMod", default)]
281 pub red_mod: Option<AttrValInt>,
282 #[serde(rename = "a:green", default)]
283 pub green: Option<AttrValInt>,
284 #[serde(rename = "a:greenOff", default)]
285 pub green_off: Option<AttrValInt>,
286 #[serde(rename = "a:greenMod", default)]
287 pub green_mod: Option<AttrValInt>,
288 #[serde(rename = "a:blue", default)]
289 pub blue: Option<AttrValInt>,
290 #[serde(rename = "a:blueOff", default)]
291 pub blue_off: Option<AttrValInt>,
292 #[serde(rename = "a:blueMod", default)]
293 pub blue_mod: Option<AttrValInt>,
294 #[serde(rename = "a:gamma", default)]
295 pub gamma: Option<AttrValInt>,
296 #[serde(rename = "a:invGamma", default)]
297 pub inv_gamma: Option<AttrValInt>,
298}
299
300#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
302pub struct ASolidFill {
303 #[serde(rename = "a:schemeClr", default)]
304 pub scheme_clr: Option<ASchemeClr>,
305 #[serde(rename = "a:srgbClr", default)]
306 pub srgb_clr: Option<ASrgbClr>,
307 #[serde(rename = "a:prstClr", default)]
308 pub prst_clr: Option<AttrValString>,
309}
310
311#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
313pub struct ALn {
314 #[serde(rename = "@algn", default)]
315 pub algn: Option<String>,
316 #[serde(rename = "@cap", default)]
317 pub cap: Option<String>,
318 #[serde(rename = "@cmpd", default)]
319 pub cmpd: Option<String>,
320 #[serde(rename = "@w", default)]
321 pub w: Option<i64>,
322 #[serde(rename = "a:noFill", default)]
323 pub no_fill: Option<AttrValString>,
324 #[serde(rename = "a:round", default)]
325 pub round: Option<String>,
326 #[serde(rename = "a:solidFill", default)]
327 pub solid_fill: Option<ASolidFill>,
328 #[serde(rename = "a:prstDash", default)]
329 pub prst_dash: Option<AttrValString>,
330 #[serde(rename = "a:prstClr", default)]
331 pub prst_clr: Option<XlsxInnerXml>,
332}
333
334#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
340pub struct XlsxSpPr {
341 #[serde(rename = "a:xfrm")]
342 pub xfrm: XlsxXfrm,
343 #[serde(rename = "a:prstGeom")]
344 pub prst_geom: XlsxPrstGeom,
345 #[serde(rename = "a:solidFill", default)]
346 pub solid_fill: Option<ASolidFill>,
347 #[serde(rename = "a:ln", default)]
348 pub ln: Option<ALn>,
349}
350
351#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
353pub struct XlsxPic {
354 #[serde(rename = "xdr:nvPicPr")]
355 pub nv_pic_pr: XlsxNvPicPr,
356 #[serde(rename = "xdr:blipFill")]
357 pub blip_fill: XlsxBlipFill,
358 #[serde(rename = "xdr:spPr")]
359 pub sp_pr: XlsxSpPr,
360}
361
362#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
368pub struct XlsxFrom {
369 #[serde(rename = "xdr:col")]
370 pub col: i64,
371 #[serde(rename = "xdr:colOff")]
372 pub col_off: i64,
373 #[serde(rename = "xdr:row")]
374 pub row: i64,
375 #[serde(rename = "xdr:rowOff")]
376 pub row_off: i64,
377}
378
379#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
381pub struct XlsxTo {
382 #[serde(rename = "xdr:col")]
383 pub col: i64,
384 #[serde(rename = "xdr:colOff")]
385 pub col_off: i64,
386 #[serde(rename = "xdr:row")]
387 pub row: i64,
388 #[serde(rename = "xdr:rowOff")]
389 pub row_off: i64,
390}
391
392#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
394pub struct XdrClientData {
395 #[serde(rename = "@fLocksWithSheet")]
396 pub f_locks_with_sheet: bool,
397 #[serde(rename = "@fPrintsWithSheet")]
398 pub f_prints_with_sheet: bool,
399}
400
401#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
403#[serde(rename = "mc:AlternateContent")]
404pub struct XlsxAlternateContent {
405 #[serde(rename = "@xmlns:mc", default)]
406 pub xmlns_mc: Option<String>,
407 #[serde(rename = "$value", default)]
408 pub content: XlsxInnerXml,
409}
410
411#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
413pub struct XdrCellAnchor {
414 #[serde(rename = "@editAs", default, skip_serializing_if = "Option::is_none")]
415 pub edit_as: Option<String>,
416 #[serde(rename = "xdr:pos", default, skip_serializing_if = "Option::is_none")]
417 pub pos: Option<XlsxPoint2D>,
418 #[serde(rename = "xdr:from", default, skip_serializing_if = "Option::is_none")]
419 pub from: Option<XlsxFrom>,
420 #[serde(rename = "xdr:to", default, skip_serializing_if = "Option::is_none")]
421 pub to: Option<XlsxTo>,
422 #[serde(rename = "xdr:ext", default, skip_serializing_if = "Option::is_none")]
423 pub ext: Option<XlsxPositiveSize2D>,
424 #[serde(rename = "xdr:sp", default, skip_serializing_if = "Option::is_none")]
425 pub sp: Option<XdrSp>,
426 #[serde(rename = "xdr:pic", default, skip_serializing_if = "Option::is_none")]
427 pub pic: Option<XlsxPic>,
428 #[serde(
429 rename = "xdr:graphicFrame",
430 default,
431 skip_serializing_if = "Option::is_none"
432 )]
433 pub graphic_frame: Option<XlsxGraphicFrame>,
434 #[serde(rename = "mc:AlternateContent", default)]
435 pub alternate_content: Vec<XlsxAlternateContent>,
436 #[serde(
437 rename = "xdr:clientData",
438 default,
439 skip_serializing_if = "Option::is_none"
440 )]
441 pub client_data: Option<XdrClientData>,
442}
443
444#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
446#[serde(rename = "xdr:pos")]
447pub struct XlsxPoint2D {
448 #[serde(rename = "@x")]
449 pub x: i64,
450 #[serde(rename = "@y")]
451 pub y: i64,
452}
453
454#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
456pub struct XlsxCellAnchorPos {
457 #[serde(rename = "@editAs", default)]
458 pub edit_as: Option<String>,
459 #[serde(rename = "xdr:from", default)]
460 pub from: Option<XlsxFrom>,
461 #[serde(rename = "xdr:to", default)]
462 pub to: Option<XlsxTo>,
463 #[serde(rename = "xdr:pos", default)]
464 pub pos: Option<XlsxInnerXml>,
465 #[serde(rename = "xdr:ext", default)]
466 pub ext: Option<XlsxPositiveSize2D>,
467 #[serde(rename = "xdr:sp", default)]
468 pub sp: Option<XlsxSp>,
469 #[serde(rename = "xdr:grpSp", default)]
470 pub grp_sp: Option<XlsxInnerXml>,
471 #[serde(rename = "xdr:graphicFrame", default)]
472 pub graphic_frame: Option<XlsxInnerXml>,
473 #[serde(rename = "xdr:cxnSp", default)]
474 pub cxn_sp: Option<XlsxInnerXml>,
475 #[serde(rename = "xdr:pic", default)]
476 pub pic: Option<XlsxInnerXml>,
477 #[serde(rename = "xdr:contentPart", default)]
478 pub content_part: Option<XlsxInnerXml>,
479 #[serde(rename = "mc:AlternateContent", default)]
480 pub alternate_content: Vec<XlsxAlternateContent>,
481 #[serde(rename = "xdr:clientData", default)]
482 pub client_data: Option<XlsxInnerXml>,
483}
484
485#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
487pub struct XlsxSp {
488 #[serde(rename = "@macro", default)]
489 pub macro_name: Option<String>,
490 #[serde(rename = "@textlink", default)]
491 pub text_link: Option<String>,
492 #[serde(rename = "@fLocksText", default)]
493 pub f_locks_text: Option<bool>,
494 #[serde(rename = "@fPublished", default)]
495 pub f_published: Option<bool>,
496 #[serde(rename = "$value", default)]
497 pub content: XlsxInnerXml,
498}
499
500#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
506#[serde(rename = "xdr:wsDr")]
507pub struct XlsxWsDr {
508 #[serde(rename = "@xmlns", default)]
509 pub ns: Option<String>,
510 #[serde(rename = "@xmlns:a", default)]
511 pub xmlns_a: Option<String>,
512 #[serde(rename = "@xmlns:xdr", default)]
513 pub xmlns_xdr: Option<String>,
514 #[serde(rename = "@xmlns:r", default)]
515 pub xmlns_r: Option<String>,
516 #[serde(rename = "mc:AlternateContent", default)]
517 pub alternate_content: Vec<XlsxAlternateContent>,
518 #[serde(rename = "xdr:absoluteAnchor", default)]
519 pub absolute_anchor: Vec<XdrCellAnchor>,
520 #[serde(rename = "xdr:oneCellAnchor", default)]
521 pub one_cell_anchor: Vec<XdrCellAnchor>,
522 #[serde(rename = "xdr:twoCellAnchor", default)]
523 pub two_cell_anchor: Vec<XdrCellAnchor>,
524}
525
526#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
532#[serde(rename = "xdr:graphicFrame")]
533pub struct XlsxGraphicFrame {
534 #[serde(rename = "@macro")]
535 pub macro_name: String,
536 #[serde(rename = "xdr:nvGraphicFramePr", alias = "nvGraphicFramePr")]
537 pub nv_graphic_frame_pr: XlsxNvGraphicFramePr,
538 #[serde(rename = "xdr:xfrm", alias = "xfrm")]
539 pub xfrm: XlsxXfrm,
540 #[serde(rename = "a:graphic", default, alias = "graphic")]
541 pub graphic: Option<XlsxGraphic>,
542}
543
544#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
546pub struct XlsxNvGraphicFramePr {
547 #[serde(rename = "xdr:cNvPr", default, alias = "cNvPr")]
548 pub c_nv_pr: Option<XlsxCNvPr>,
549 #[serde(rename = "xdr:cNvGraphicFramePr", alias = "cNvGraphicFramePr")]
550 pub c_nv_graphic_frame_pr: String,
551}
552
553#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
555pub struct XlsxGraphic {
556 #[serde(rename = "a:graphicData", default, alias = "graphicData")]
557 pub graphic_data: Option<XlsxGraphicData>,
558}
559
560#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
562pub struct XlsxGraphicData {
563 #[serde(rename = "@uri")]
564 pub uri: String,
565 #[serde(rename = "c:chart", default, alias = "chart")]
566 pub chart: Option<XlsxChart>,
567 #[serde(
568 rename = "sle:slicer",
569 default,
570 alias = "slicer",
571 skip_serializing_if = "Option::is_none"
572 )]
573 pub sle: Option<XlsxSle>,
574}
575
576#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
578pub struct XlsxSle {
579 #[serde(rename = "@xmlns:sle")]
580 pub xmlns_sle: String,
581 #[serde(rename = "@name")]
582 pub name: String,
583}
584
585#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
587pub struct XlsxChart {
588 #[serde(rename = "@xmlns:c")]
589 pub xmlns_c: String,
590 #[serde(rename = "@r:id", alias = "@id")]
591 pub r_id: String,
592 #[serde(rename = "@xmlns:r")]
593 pub xmlns_r: String,
594}
595
596#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
602#[serde(rename = "xdr:sp")]
603pub struct XdrSp {
604 #[serde(rename = "@macro")]
605 pub macro_name: String,
606 #[serde(rename = "@textlink")]
607 pub text_link: String,
608 #[serde(rename = "xdr:nvSpPr", default)]
609 pub nv_sp_pr: Option<XdrNvSpPr>,
610 #[serde(rename = "xdr:spPr", default)]
611 pub sp_pr: Option<XlsxSpPr>,
612 #[serde(rename = "xdr:style", default)]
613 pub style: Option<XdrStyle>,
614 #[serde(rename = "xdr:txBody", default)]
615 pub tx_body: Option<XdrTxBody>,
616}
617
618#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
620pub struct XdrNvSpPr {
621 #[serde(rename = "xdr:cNvPr", default)]
622 pub c_nv_pr: Option<XlsxCNvPr>,
623 #[serde(rename = "xdr:cNvSpPr", default)]
624 pub c_nv_sp_pr: Option<XdrCNvSpPr>,
625}
626
627#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
629pub struct XdrCNvSpPr {
630 #[serde(rename = "@txBox")]
631 pub tx_box: bool,
632}
633
634#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
636pub struct XdrStyle {
637 #[serde(rename = "a:lnRef", default)]
638 pub ln_ref: Option<ARef>,
639 #[serde(rename = "a:fillRef", default)]
640 pub fill_ref: Option<ARef>,
641 #[serde(rename = "a:effectRef", default)]
642 pub effect_ref: Option<ARef>,
643 #[serde(rename = "a:fontRef", default)]
644 pub font_ref: Option<AFontRef>,
645}
646
647#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
649pub struct ARef {
650 #[serde(rename = "@idx")]
651 pub idx: i64,
652 #[serde(rename = "a:scrgbClr", default)]
653 pub scrgb_clr: Option<AScrgbClr>,
654 #[serde(rename = "a:schemeClr", default)]
655 pub scheme_clr: Option<AttrValString>,
656 #[serde(rename = "a:srgbClr", default)]
657 pub srgb_clr: Option<AttrValString>,
658}
659
660#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
662pub struct AFontRef {
663 #[serde(rename = "@idx")]
664 pub idx: String,
665 #[serde(rename = "a:schemeClr", default)]
666 pub scheme_clr: Option<AttrValString>,
667}
668
669#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
675pub struct XdrTxBody {
676 #[serde(rename = "a:bodyPr", default)]
677 pub body_pr: Option<ABodyPr>,
678 #[serde(rename = "a:p", default)]
679 pub p: Vec<AP>,
680}
681
682#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
684pub struct ABodyPr {
685 #[serde(rename = "@anchor", default)]
686 pub anchor: Option<String>,
687 #[serde(rename = "@anchorCtr")]
688 pub anchor_ctr: bool,
689 #[serde(rename = "@rot")]
690 pub rot: i64,
691 #[serde(rename = "@bIns", default)]
692 pub b_ins: Option<f64>,
693 #[serde(rename = "@compatLnSpc", default)]
694 pub compat_ln_spc: Option<bool>,
695 #[serde(rename = "@forceAA", default)]
696 pub force_aa: Option<bool>,
697 #[serde(rename = "@fromWordArt", default)]
698 pub from_word_art: Option<bool>,
699 #[serde(rename = "@horzOverflow", default)]
700 pub horz_overflow: Option<String>,
701 #[serde(rename = "@lIns", default)]
702 pub l_ins: Option<f64>,
703 #[serde(rename = "@numCol", default)]
704 pub num_col: Option<i64>,
705 #[serde(rename = "@rIns", default)]
706 pub r_ins: Option<f64>,
707 #[serde(rename = "@rtlCol", default)]
708 pub rtl_col: Option<bool>,
709 #[serde(rename = "@spcCol", default)]
710 pub spc_col: Option<i64>,
711 #[serde(rename = "@spcFirstLastPara")]
712 pub spc_first_last_para: bool,
713 #[serde(rename = "@tIns", default)]
714 pub t_ins: Option<f64>,
715 #[serde(rename = "@upright", default)]
716 pub upright: Option<bool>,
717 #[serde(rename = "@vert", default)]
718 pub vert: Option<String>,
719 #[serde(rename = "@vertOverflow", default)]
720 pub vert_overflow: Option<String>,
721 #[serde(rename = "@wrap", default)]
722 pub wrap: Option<String>,
723}
724
725#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
727pub struct AP {
728 #[serde(rename = "a:pPr", default)]
729 pub p_pr: Option<APPr>,
730 #[serde(rename = "a:r", default)]
731 pub r: Option<AR>,
732 #[serde(rename = "a:endParaRPr", default)]
733 pub end_para_r_pr: Option<AEndParaRPr>,
734}
735
736#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
738pub struct APPr {
739 #[serde(rename = "a:defRPr")]
740 pub def_r_pr: ARPr,
741}
742
743#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
745pub struct AR {
746 #[serde(rename = "a:rPr", default)]
747 pub r_pr: Option<ARPr>,
748 #[serde(rename = "a:t", default)]
749 pub t: Option<String>,
750}
751
752#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
754pub struct ARPr {
755 #[serde(rename = "@altLang", default)]
756 pub alt_lang: Option<String>,
757 #[serde(rename = "@b")]
758 pub b: bool,
759 #[serde(rename = "@baseline")]
760 pub baseline: i64,
761 #[serde(rename = "@bmk", default)]
762 pub bmk: Option<String>,
763 #[serde(rename = "@cap", default)]
764 pub cap: Option<String>,
765 #[serde(rename = "@dirty", default)]
766 pub dirty: Option<bool>,
767 #[serde(rename = "@err", default)]
768 pub err: Option<bool>,
769 #[serde(rename = "@i")]
770 pub i: bool,
771 #[serde(rename = "@kern")]
772 pub kern: i64,
773 #[serde(rename = "@kumimoji", default)]
774 pub kumimoji: Option<bool>,
775 #[serde(rename = "@lang", default)]
776 pub lang: Option<String>,
777 #[serde(rename = "@noProof", default)]
778 pub no_proof: Option<bool>,
779 #[serde(rename = "@normalizeH", default)]
780 pub normalize_h: Option<bool>,
781 #[serde(rename = "@smtClean", default)]
782 pub smt_clean: Option<bool>,
783 #[serde(rename = "@smtId", default)]
784 pub smt_id: Option<u64>,
785 #[serde(rename = "@spc")]
786 pub spc: i64,
787 #[serde(rename = "@strike", default)]
788 pub strike: Option<String>,
789 #[serde(rename = "@sz", default)]
790 pub sz: Option<f64>,
791 #[serde(rename = "@u", default)]
792 pub u: Option<String>,
793 #[serde(rename = "a:solidFill", default)]
794 pub solid_fill: Option<ASolidFill>,
795 #[serde(rename = "a:latin", default)]
796 pub latin: Option<XlsxCTTextFont>,
797 #[serde(rename = "a:ea", default)]
798 pub ea: Option<XlsxCTTextFont>,
799 #[serde(rename = "a:cs", default)]
800 pub cs: Option<XlsxCTTextFont>,
801}
802
803#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
805pub struct AEndParaRPr {
806 #[serde(rename = "@lang")]
807 pub lang: String,
808 #[serde(rename = "@altLang", default)]
809 pub alt_lang: Option<String>,
810 #[serde(rename = "@sz", default)]
811 pub sz: Option<i64>,
812}
813
814#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
816pub struct XlsxCTTextFont {
817 #[serde(rename = "@typeface")]
818 pub typeface: String,
819 #[serde(rename = "@panose", default)]
820 pub panose: Option<String>,
821 #[serde(rename = "@pitchFamily", default)]
822 pub pitch_family: Option<String>,
823 #[serde(rename = "@Charset", default)]
824 pub charset: Option<String>,
825}
826
827#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
833pub struct PictureInsertType(pub u8);
834
835impl PictureInsertType {
836 pub const PLACE_OVER_CELLS: PictureInsertType = PictureInsertType(0);
837 pub const PLACE_IN_CELL: PictureInsertType = PictureInsertType(1);
838 pub const IMAGE: PictureInsertType = PictureInsertType(2);
839 pub const DISPIMG: PictureInsertType = PictureInsertType(3);
840}
841
842#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
844pub struct LineType(pub u8);
845
846impl LineType {
847 pub const UNSET: LineType = LineType(0);
848 pub const SOLID: LineType = LineType(1);
849 pub const NONE: LineType = LineType(2);
850 pub const AUTOMATIC: LineType = LineType(3);
851}
852
853#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
855pub struct LineDashType(pub u8);
856
857impl LineDashType {
858 pub const UNSET: LineDashType = LineDashType(0);
859 pub const SOLID: LineDashType = LineDashType(1);
860 pub const DOT: LineDashType = LineDashType(2);
861 pub const DASH: LineDashType = LineDashType(3);
862 pub const LG_DASH: LineDashType = LineDashType(4);
863 pub const SASH_DOT: LineDashType = LineDashType(5);
864 pub const LG_DASH_DOT: LineDashType = LineDashType(6);
865 pub const LG_DASH_DOT_DOT: LineDashType = LineDashType(7);
866 pub const SYS_DASH: LineDashType = LineDashType(8);
867 pub const SYS_DOT: LineDashType = LineDashType(9);
868 pub const SYS_DASH_DOT: LineDashType = LineDashType(10);
869 pub const SYS_DASH_DOT_DOT: LineDashType = LineDashType(11);
870}
871
872#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
874pub struct Fill {
875 #[serde(default)]
876 pub r#type: String,
877 pub pattern: i64,
878 #[serde(default)]
879 pub color: Vec<String>,
880 pub shading: i64,
881 pub transparency: i64,
882}
883
884#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
886pub struct LineOptions {
887 pub r#type: LineType,
888 pub dash: LineDashType,
889 pub fill: Fill,
890 pub smooth: bool,
891 pub width: f64,
892}
893
894#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
896pub struct Picture {
897 #[serde(default)]
898 pub extension: String,
899 #[serde(default)]
900 pub file: Vec<u8>,
901 #[serde(default)]
902 pub format: Option<GraphicOptions>,
903 pub insert_type: PictureInsertType,
904}
905
906#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
908pub struct GraphicOptions {
909 #[serde(default)]
910 pub alt_text: String,
911 #[serde(default)]
912 pub name: String,
913 #[serde(default)]
914 pub print_object: Option<bool>,
915 #[serde(default)]
916 pub locked: Option<bool>,
917 pub lock_aspect_ratio: bool,
918 pub auto_fit: bool,
919 pub auto_fit_ignore_aspect: bool,
920 pub offset_x: i64,
921 pub offset_y: i64,
922 pub scale_x: f64,
923 pub scale_y: f64,
924 #[serde(default)]
925 pub hyperlink: String,
926 #[serde(default)]
927 pub hyperlink_type: String,
928 #[serde(default)]
929 pub positioning: String,
930}
931
932#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
934pub struct Shape {
935 #[serde(default)]
936 pub cell: String,
937 #[serde(default)]
938 pub r#type: String,
939 #[serde(default)]
940 pub macro_name: String,
941 pub width: u64,
942 pub height: u64,
943 pub format: GraphicOptions,
944 pub fill: Fill,
945 pub line: LineOptions,
946 #[serde(default)]
947 pub paragraph: Vec<RichTextRun>,
948}