1use super::defaults::*;
2use super::simple_types::*;
3#[derive(XmlSerialize, XmlDeserialize, Default, Debug, Clone)]
4pub struct CtRst {
5 #[xmlserde(name = b"t", ty = "child")]
6 pub t: Option<PlainTextString>,
7 #[xmlserde(name = b"r", ty = "child")]
8 pub r: Vec<CtRElt>,
9 #[xmlserde(name = b"rPh", ty = "child")]
10 pub r_ph: Vec<CtPhoneticRun>,
11 #[xmlserde(name = b"phoneticPr", ty = "child")]
12 pub phonetic_pr: Option<CtPhoneticPr>,
13}
14
15#[derive(XmlSerialize, XmlDeserialize, Default, Debug, Clone)]
16pub struct CtRElt {
17 #[xmlserde(name = b"rPr", ty = "child")]
18 pub r_pr: Option<CtRPrElt>,
19 #[xmlserde(name = b"t", ty = "child")]
20 pub t: PlainTextString,
21}
22
23#[derive(XmlSerialize, XmlDeserialize, Default, Debug, Clone)]
24pub struct PlainTextString {
25 #[xmlserde(ty = "text", default = "empty_string")]
26 pub value: String,
27 #[xmlserde(ty = "attr", name = b"xml:space")]
28 pub space: Option<String>,
29}
30
31#[derive(XmlSerialize, XmlDeserialize, Default, Debug)]
32pub struct PlainTextU32 {
33 #[xmlserde(ty = "text")]
34 pub value: i32,
35}
36
37#[derive(XmlSerialize, XmlDeserialize, Default, Debug, Clone)]
38pub struct CtRPrElt {
39 #[xmlserde(name = b"b", ty = "sfc")]
40 pub bold: bool,
41 #[xmlserde(name = b"i", ty = "sfc")]
42 pub italic: bool,
43 #[xmlserde(name = b"strike", ty = "sfc")]
44 pub strike: bool,
45 #[xmlserde(name = b"outline", ty = "sfc")]
46 pub outline: bool,
47 #[xmlserde(name = b"shadow", ty = "sfc")]
48 pub shadow: bool,
49 #[xmlserde(name = b"condense", ty = "sfc")]
50 pub condense: bool,
51 #[xmlserde(name = b"extend", ty = "sfc")]
52 pub extend: bool,
53 #[xmlserde(name = b"sz", ty = "child")]
54 pub size: Option<CtFontSize>,
55 #[xmlserde(name = b"color", ty = "child")]
56 pub color: Option<CtColor>,
57 #[xmlserde(name = b"rFont", ty = "child")]
58 pub r_font: Option<CtFontName>,
59 #[xmlserde(name = b"family", ty = "child")]
60 pub family: Option<CtIntProperty>,
61 #[xmlserde(name = b"charset", ty = "child")]
62 pub charset: Option<CtIntProperty>,
63 #[xmlserde(name = b"u", ty = "child")]
64 pub u: Option<CtUnderlineProperty>,
65 #[xmlserde(name = b"vertAlign", ty = "child")]
66 pub vert_align: Option<CtVerticalAlignFontProperty>,
67 #[xmlserde(name = b"scheme", ty = "child")]
68 pub scheme: Option<CtFontScheme>,
69}
70
71#[derive(
72 XmlSerialize, XmlDeserialize, Default, Debug, Hash, PartialEq, Eq, Clone, serde::Serialize, TS,
73)]
74#[ts(export, export_to = "../../../src/bindings/font_name.ts")]
75#[serde(rename_all = "camelCase")]
76pub struct CtFontName {
77 #[xmlserde(name = b"val", ty = "attr")]
78 pub val: String,
79}
80
81#[derive(XmlSerialize, XmlDeserialize, Debug, Clone)]
82pub struct CtPhoneticPr {
83 #[xmlserde(name = b"fontId", ty = "attr")]
84 pub font_id: StFontId,
85 #[xmlserde(name = b"type", ty = "attr", default = "fullwidth_katakana")]
86 pub ty: StPhoneticType,
87 #[xmlserde(
88 name = b"alignment",
89 ty = "attr",
90 default = "st_phonetic_alignment_left"
91 )]
92 pub alignment: StPhoneticAlignment,
93}
94
95#[derive(XmlSerialize, XmlDeserialize, Debug, Clone)]
96pub struct CtPhoneticRun {
97 #[xmlserde(name = b"t", ty = "child")]
98 pub t: PlainTextString,
99 #[xmlserde(name = b"sb", ty = "attr")]
100 pub sb: u32,
101 #[xmlserde(name = b"eb", ty = "attr")]
102 pub eb: u32,
103}
104
105#[derive(XmlSerialize, XmlDeserialize, Debug)]
106pub struct CtColors {
107 #[xmlserde(name = b"indexedColors", ty = "child")]
108 pub indexed_colors: Option<CtIndexedColors>,
109 #[xmlserde(name = b"mruColors", ty = "child")]
110 pub mru_colors: Option<CtMruColors>,
111}
112
113#[derive(XmlSerialize, XmlDeserialize, Debug)]
114pub struct CtIndexedColors {
115 #[xmlserde(name = b"rgbColor", ty = "child")]
116 pub rgb_color: Vec<CtRgbColor>,
117}
118
119#[derive(XmlSerialize, XmlDeserialize, Debug)]
120pub struct CtRgbColor {
121 #[xmlserde(name = b"rgb", ty = "attr")]
122 pub rgb: Option<StUnsignedIntHex>,
123}
124
125#[derive(XmlSerialize, XmlDeserialize, Debug)]
126pub struct CtMruColors {
127 #[xmlserde(name = b"color", ty = "child")]
128 pub color: Vec<CtColor>,
129}
130
131#[derive(XmlSerialize, XmlDeserialize, Debug, Clone, MapObj)]
132pub struct CtColor {
133 #[xmlserde(name = b"auto", ty = "attr")]
134 pub auto: Option<bool>,
135 #[xmlserde(name = b"indexed", ty = "attr")]
136 pub indexed: Option<u32>,
137 #[xmlserde(name = b"rgb", ty = "attr")]
138 pub rgb: Option<StUnsignedIntHex>,
139 #[xmlserde(name = b"theme", ty = "attr")]
140 pub theme: Option<u32>,
141 #[xmlserde(name = b"tint", ty = "attr", default = "default_zero_f64")]
142 pub tint: f64,
143}
144
145#[derive(XmlSerialize, XmlDeserialize, Debug, Hash, PartialEq, Eq, Clone)]
146pub struct CtBorder {
147 #[xmlserde(name = b"left", ty = "child")]
148 pub left: Option<CtBorderPr>,
149 #[xmlserde(name = b"right", ty = "child")]
150 pub right: Option<CtBorderPr>,
151 #[xmlserde(name = b"top", ty = "child")]
152 pub top: Option<CtBorderPr>,
153 #[xmlserde(name = b"bottom", ty = "child")]
154 pub bottom: Option<CtBorderPr>,
155 #[xmlserde(name = b"diagonal", ty = "child")]
156 pub diagonal: Option<CtBorderPr>,
157 #[xmlserde(name = b"vertical", ty = "child")]
158 pub vertical: Option<CtBorderPr>,
159 #[xmlserde(name = b"horizontal", ty = "child")]
160 pub horizontal: Option<CtBorderPr>,
161 #[xmlserde(name = b"diagonalUp", ty = "attr")]
162 pub diagonal_up: Option<bool>,
163 #[xmlserde(name = b"diagonalDown", ty = "attr")]
164 pub diagonal_down: Option<bool>,
165 #[xmlserde(name = b"outline", ty = "attr", default = "default_true")]
166 pub outline: bool,
167}
168
169#[derive(XmlSerialize, XmlDeserialize, Debug, Hash, PartialEq, Eq, Clone)]
170pub struct CtBorderPr {
171 #[xmlserde(name = b"color", ty = "child")]
172 pub color: Option<CtColor>,
173 #[xmlserde(name = b"style", ty = "attr", default = "border_style_none")]
174 pub style: StBorderStyle,
175}
176
177#[derive(XmlSerialize, XmlDeserialize, Debug)]
178pub struct CtBorders {
179 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
180 pub count: u32,
181 #[xmlserde(name = b"border", ty = "child", vec_size = "count")]
182 pub borders: Vec<CtBorder>,
183}
184
185#[derive(XmlSerialize, XmlDeserialize, Debug)]
186pub struct CtCellStyles {
187 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
188 pub count: u32,
189 #[xmlserde(name = b"cellStyle", ty = "child", vec_size = "count")]
190 pub cell_styles: Vec<CtCellStyle>,
191}
192
193#[derive(XmlSerialize, XmlDeserialize, Debug)]
194pub struct CtCellStyle {
195 #[xmlserde(name = b"name", ty = "attr")]
196 pub name: Option<String>,
197 #[xmlserde(name = b"xfId", ty = "attr")]
198 pub xf_id: StCellStyleXfId,
199 #[xmlserde(name = b"builtinId", ty = "attr")]
200 pub builtin_id: Option<u32>,
201 #[xmlserde(name = b"iLevel", ty = "attr")]
202 pub i_level: Option<u32>,
203 #[xmlserde(name = b"customBuiltin", ty = "attr")]
204 pub custom_builtin: Option<bool>,
205}
206
207#[derive(XmlSerialize, XmlDeserialize, Debug, Clone, Hash, PartialEq, Eq)]
208pub struct CtPatternFill {
209 #[xmlserde(name = b"fgColor", ty = "child")]
210 pub fg_color: Option<CtColor>,
211 #[xmlserde(name = b"bgColor", ty = "child")]
212 pub bg_color: Option<CtColor>,
213 #[xmlserde(name = b"patternType", ty = "attr")]
214 pub pattern_type: Option<StPatternType>,
215}
216
217#[derive(XmlSerialize, XmlDeserialize, Debug, Clone, MapObj)]
218pub struct CtGradientFill {
219 #[xmlserde(name = b"stop", ty = "child")]
220 pub stops: Vec<CtGradientStop>,
221 #[xmlserde(name = b"type", ty = "attr", default = "st_gradient_type_linear")]
222 pub ty: StGradientType,
223 #[xmlserde(name = b"degree", ty = "attr", default = "default_zero_f64")]
224 pub degree: f64,
225 #[xmlserde(name = b"left", ty = "attr", default = "default_zero_f64")]
226 pub left: f64,
227 #[xmlserde(name = b"right", ty = "attr", default = "default_zero_f64")]
228 pub right: f64,
229 #[xmlserde(name = b"top", ty = "attr", default = "default_zero_f64")]
230 pub top: f64,
231 #[xmlserde(name = b"bottom", ty = "attr", default = "default_zero_f64")]
232 pub bottom: f64,
233}
234
235#[derive(XmlSerialize, XmlDeserialize, Debug, Clone, MapObj)]
236pub struct CtGradientStop {
237 #[xmlserde(name = b"color", ty = "child")]
238 pub color: CtColor,
239 #[xmlserde(name = b"position", ty = "attr")]
240 pub position: f64,
241}
242
243#[derive(XmlSerialize, XmlDeserialize, Debug)]
244pub struct CtFills {
245 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
246 pub count: u32,
247 #[xmlserde(name = b"fill", ty = "child", vec_size = "count")]
248 pub fills: Vec<CtFill>,
249}
250
251#[derive(Debug, Clone, Hash, Eq, PartialEq)]
252pub enum CtFill {
253 PatternFill(CtPatternFill),
254 GradientFill(CtGradientFill),
255}
256
257impl crate::XmlSerialize for CtFill {
258 fn serialize<W: std::io::Write>(&self, tag: &[u8], writer: &mut quick_xml::Writer<W>) {
259 use quick_xml::events::*;
260 let _ = writer.write_event(Event::Start(BytesStart::borrowed_name(tag)));
261 match self {
262 CtFill::PatternFill(p) => p.serialize(b"patternFill", writer),
263 CtFill::GradientFill(f) => f.serialize(b"gradientFill", writer),
264 }
265 let _ = writer.write_event(Event::End(BytesEnd::borrowed(tag)));
266 }
267}
268
269impl crate::XmlDeserialize for CtFill {
270 fn deserialize<B: std::io::BufRead>(
271 tag: &[u8],
272 reader: &mut quick_xml::Reader<B>,
273 _attrs: quick_xml::events::attributes::Attributes,
274 _is_empty: bool,
275 ) -> Self {
276 use quick_xml::events::*;
277 let mut buf = Vec::<u8>::new();
278 let mut result = Option::<Self>::None;
279 loop {
280 match reader.read_event(&mut buf) {
281 Ok(Event::Start(s)) => match s.name() {
282 b"patternFill" => {
283 let r = CtPatternFill::deserialize(
284 b"patternFill",
285 reader,
286 s.attributes(),
287 false,
288 );
289 result = Some(Self::PatternFill(r));
290 }
291 b"gradientFill" => {
292 let r = CtGradientFill::deserialize(
293 b"gradientFill",
294 reader,
295 s.attributes(),
296 false,
297 );
298 result = Some(Self::GradientFill(r));
299 }
300 _ => {}
301 },
302 Ok(Event::Empty(s)) => match s.name() {
303 b"patternFill" => {
304 let r = CtPatternFill::deserialize(
305 b"patternFill",
306 reader,
307 s.attributes(),
308 true,
309 );
310 result = Some(Self::PatternFill(r));
311 }
312 b"gradientFill" => {
313 let r = CtGradientFill::deserialize(
314 b"gradientFill",
315 reader,
316 s.attributes(),
317 true,
318 );
319 result = Some(Self::GradientFill(r));
320 }
321 _ => {}
322 },
323 Ok(Event::End(e)) => {
324 if e.name() == tag {
325 break;
326 }
327 }
328 Ok(Event::Eof) => break,
329 _ => {}
330 }
331 }
332 return result.unwrap();
333 }
334}
335
336#[derive(Debug, XmlSerialize, XmlDeserialize, PartialEq, Eq, Clone, Hash, serde::Serialize, TS)]
337#[ts(export, export_to = "../../../src/bindings/cell_alignment.ts")]
338#[serde(rename_all = "camelCase")]
339pub struct CtCellAlignment {
340 #[xmlserde(name = b"horizontal", ty = "attr")]
341 pub horizontal: Option<StHorizontalAlignment>,
342 #[xmlserde(name = b"vertical", ty = "attr")]
343 pub vertical: Option<StVerticalAlignment>,
344 #[xmlserde(name = b"text_rotation", ty = "attr")]
345 pub text_rotation: Option<u32>,
346 #[xmlserde(name = b"wrapText", ty = "attr")]
347 pub wrap_text: Option<bool>,
348 #[xmlserde(name = b"indent", ty = "attr")]
349 pub indent: Option<u32>,
350 #[xmlserde(name = b"relativeIndent", ty = "attr")]
351 pub relative_indent: Option<i32>,
352 #[xmlserde(name = b"justifyLastLine", ty = "attr")]
353 pub justify_last_line: Option<bool>,
354 #[xmlserde(name = b"shrinkToFit", ty = "attr")]
355 pub shrink_to_fit: Option<bool>,
356 #[xmlserde(name = b"readingOrder", ty = "attr")]
357 pub reading_order: Option<u32>,
358}
359
360#[derive(Debug, XmlSerialize, XmlDeserialize, Hash, Eq, PartialEq, Clone, serde::Serialize, TS)]
361#[ts(export, export_to = "../../../src/bindings/cell_protection.ts")]
362#[serde(rename_all = "camelCase")]
363pub struct CtCellProtection {
364 #[xmlserde(name = b"locked", ty = "attr")]
365 pub locked: Option<bool>,
366 #[xmlserde(name = b"hidden", ty = "attr")]
367 pub hidden: Option<bool>,
368}
369
370#[derive(Debug, XmlSerialize, XmlDeserialize, Hash, PartialEq, Eq, Clone, serde::Serialize, TS)]
371#[ts(export, export_to = "../../../src/bindings/font_scheme.ts")]
372pub struct CtFontScheme {
373 #[xmlserde(name = b"val", ty = "attr")]
374 pub val: StFontScheme,
375}
376
377#[derive(Debug, XmlSerialize, XmlDeserialize)]
378pub struct CtFonts {
379 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
380 pub count: u32,
381 #[xmlserde(name = b"font", ty = "child", vec_size = "count")]
382 pub fonts: Vec<CtFont>,
383}
384
385#[derive(Debug, XmlSerialize, XmlDeserialize, Hash, Eq, PartialEq, Clone)]
386pub struct CtFont {
387 #[xmlserde(name = b"b", ty = "sfc")]
388 pub bold: bool,
389 #[xmlserde(name = b"i", ty = "sfc")]
390 pub italic: bool,
391 #[xmlserde(name = b"u", ty = "child")]
392 pub underline: Option<CtUnderlineProperty>,
393 #[xmlserde(name = b"color", ty = "child")]
394 pub color: Option<CtColor>,
395 #[xmlserde(name = b"sz", ty = "child")]
396 pub sz: Option<CtFontSize>,
397 #[xmlserde(name = b"name", ty = "child")]
398 pub name: Option<CtFontName>,
399 #[xmlserde(name = b"charset", ty = "child")]
400 pub charset: Option<CtIntProperty>,
401 #[xmlserde(name = b"family", ty = "child")]
402 pub family: Option<CtFontFamily>,
403 #[xmlserde(name = b"strike", ty = "sfc")]
404 pub strike: bool,
405 #[xmlserde(name = b"outline", ty = "sfc")]
406 pub outline: bool,
407 #[xmlserde(name = b"shadow", ty = "sfc")]
408 pub shadow: bool,
409 #[xmlserde(name = b"condense", ty = "sfc")]
410 pub condense: bool,
411 #[xmlserde(name = b"extend", ty = "sfc")]
412 pub extend: bool,
413 #[xmlserde(name = b"vertAlign", ty = "child")]
414 pub vert_align: Option<CtVerticalAlignFontProperty>,
415 #[xmlserde(name = b"scheme", ty = "child")]
416 pub scheme: Option<CtFontScheme>,
417}
418
419#[derive(Debug, XmlSerialize, XmlDeserialize, Hash, PartialEq, Eq, Clone, serde::Serialize, TS)]
420#[ts(
421 export,
422 export_to = "../../../src/bindings/vertical_align_font_property.ts"
423)]
424#[serde(rename_all = "camelCase")]
425pub struct CtVerticalAlignFontProperty {
426 #[xmlserde(name = b"val", ty = "attr")]
427 pub val: StVerticalAlignRun,
428}
429
430#[derive(Debug, XmlSerialize, XmlDeserialize, MapObj, Clone, serde::Serialize, TS)]
431#[ts(export, export_to = "../../../src/bindings/font_size.ts")]
432#[serde(rename_all = "camelCase")]
433pub struct CtFontSize {
434 #[xmlserde(name = b"val", ty = "attr")]
435 pub val: f64,
436}
437
438#[derive(Debug, XmlSerialize, XmlDeserialize, Hash, PartialEq, Eq, Clone, serde::Serialize, TS)]
439#[ts(export, export_to = "../../../src/bindings/int_property.ts")]
440#[serde(rename_all = "camelCase")]
441pub struct CtIntProperty {
442 #[xmlserde(name = b"val", ty = "attr")]
443 pub val: i32,
444}
445
446#[derive(Debug, XmlSerialize, XmlDeserialize, Hash, PartialEq, Eq, Clone, serde::Serialize, TS)]
447#[ts(export, export_to = "../../../src/bindings/underline_property.ts")]
448pub struct CtUnderlineProperty {
449 #[xmlserde(name = b"val", ty = "attr", default = "st_underline_values_single")]
450 pub val: StUnderlineValues,
451}
452
453#[derive(Debug, XmlSerialize, XmlDeserialize, Hash, PartialEq, Eq, Clone, serde::Serialize, TS)]
454#[ts(export, export_to = "../../../src/bindings/font_family.ts")]
455#[serde(rename_all = "camelCase")]
456pub struct CtFontFamily {
457 #[xmlserde(name = b"val", ty = "attr")]
458 pub val: StFontFamily,
459}
460
461#[derive(Debug, XmlSerialize, XmlDeserialize)]
462pub struct CtTableStyle {
463 #[xmlserde(name = b"name", ty = "attr")]
464 pub name: String,
465 #[xmlserde(name = b"pivot", ty = "attr", default = "default_true")]
466 pub pivot: bool,
467 #[xmlserde(name = b"table", ty = "attr", default = "default_true")]
468 pub table: bool,
469 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
470 pub count: u32,
471 #[xmlserde(name = b"tableStyleElement", ty = "child", vec_size = "count")]
472 pub table_style_elements: Vec<CtTableStyleElement>,
473}
474
475#[derive(Debug, XmlSerialize, XmlDeserialize)]
476pub struct CtTableStyles {
477 #[xmlserde(name = b"tableStyle", ty = "child", vec_size = "count")]
478 pub table_styles: Vec<CtTableStyle>,
479 #[xmlserde(name = b"count", default = "default_zero_u32", ty = "attr")]
480 pub count: u32,
481 #[xmlserde(name = b"defaultTableStyle", ty = "attr")]
482 pub default_table_style: Option<String>,
483 #[xmlserde(name = b"defaultPivotStyle", ty = "attr")]
484 pub default_pivot_style: Option<String>,
485}
486
487#[derive(Debug, XmlSerialize, XmlDeserialize)]
488pub struct CtTableStyleElement {
489 #[xmlserde(name = b"type", ty = "attr")]
490 pub ty: StTableStyleType,
491 #[xmlserde(name = b"size", ty = "attr", default = "default_one_u32")]
492 pub size: u32,
493 #[xmlserde(name = b"dxfId", ty = "attr")]
494 pub dxf_id: Option<StDxfId>,
495}
496
497#[derive(Debug, XmlSerialize, XmlDeserialize)]
498pub struct CtDxfs {
499 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
500 pub count: u32,
501 #[xmlserde(name = b"dxf", ty = "child", vec_size = "count")]
502 pub dxfs: Vec<CtDxf>,
503}
504
505#[derive(Debug, XmlSerialize, XmlDeserialize)]
506pub struct CtDxf {
507 #[xmlserde(name = b"font", ty = "child")]
508 pub font: Option<CtFont>,
509 #[xmlserde(name = b"numFmt", ty = "child")]
510 pub num_fmt: Option<CtNumFmt>,
511 #[xmlserde(name = b"fill", ty = "child")]
512 pub fill: Option<CtFill>,
513 #[xmlserde(name = b"alignment", ty = "child")]
514 pub alignment: Option<CtCellAlignment>,
515 #[xmlserde(name = b"border", ty = "child")]
516 pub border: Option<CtBorder>,
517 #[xmlserde(name = b"protection", ty = "child")]
518 pub protection: Option<CtCellProtection>,
519}
520
521#[derive(Debug, XmlSerialize, XmlDeserialize)]
522pub struct CtNumFmt {
523 #[xmlserde(name = b"numFmtId", ty = "attr")]
524 pub num_fmt_id: StNumFmtId,
525 #[xmlserde(name = b"formatCode", ty = "attr")]
526 pub format_code: String,
527}
528
529#[derive(Debug, XmlSerialize, XmlDeserialize)]
530pub struct CtNumFmts {
531 #[xmlserde(name = b"numFmt", ty = "child", vec_size = "count")]
532 pub num_fmts: Vec<CtNumFmt>,
533 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
534 pub count: u32,
535}
536
537#[derive(Debug, XmlSerialize, XmlDeserialize)]
538pub struct CtXf {
539 #[xmlserde(name = b"alignment", ty = "child")]
540 pub alignment: Option<CtCellAlignment>,
541 #[xmlserde(name = b"protection", ty = "child")]
542 pub protction: Option<CtCellProtection>,
543 #[xmlserde(name = b"numFmtId", ty = "attr")]
544 pub num_fmt_id: Option<StNumFmtId>,
545 #[xmlserde(name = b"fontId", ty = "attr")]
546 pub font_id: Option<StFontId>,
547 #[xmlserde(name = b"fillId", ty = "attr")]
548 pub fill_id: Option<StFillId>,
549 #[xmlserde(name = b"borderId", ty = "attr")]
550 pub border_id: Option<StBorderId>,
551 #[xmlserde(name = b"xfId", ty = "attr")]
552 pub xf_id: Option<StCellStyleXfId>,
553 #[xmlserde(name = b"quotePrefix", ty = "attr", default = "default_false")]
554 pub quote_prefix: bool,
555 #[xmlserde(name = b"pivotButton", ty = "attr", default = "default_false")]
556 pub pivot_button: bool,
557 #[xmlserde(name = b"applyNumberFormat", ty = "attr")]
558 pub apply_number_format: Option<bool>,
559 #[xmlserde(name = b"applyFont", ty = "attr")]
560 pub apply_font: Option<bool>,
561 #[xmlserde(name = b"applyFill", ty = "attr")]
562 pub apply_fill: Option<bool>,
563 #[xmlserde(name = b"applyBorder", ty = "attr")]
564 pub apply_border: Option<bool>,
565 #[xmlserde(name = b"applyAlignment", ty = "attr")]
566 pub apply_alignment: Option<bool>,
567 #[xmlserde(name = b"applyProtection", ty = "attr")]
568 pub apply_protection: Option<bool>,
569}
570
571#[derive(Debug, XmlDeserialize, XmlSerialize)]
572pub struct CtCellStyleXfs {
573 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
574 pub count: u32,
575 #[xmlserde(name = b"xf", ty = "child", vec_size = "count")]
576 pub xfs: Vec<CtXf>,
577}
578
579#[derive(Debug, XmlDeserialize, XmlSerialize)]
580pub struct CtCellXfs {
581 #[xmlserde(name = b"xf", ty = "child", vec_size = "count")]
582 pub xfs: Vec<CtXf>,
583 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
584 pub count: u32,
585}
586
587#[derive(Debug, XmlSerialize, XmlDeserialize)]
588pub struct CtComment {
589 #[xmlserde(name = b"text", ty = "child")]
590 pub text: CtRst,
591 #[xmlserde(name = b"commentPr", ty = "child")]
592 pub comment_pr: Option<CtCommentPr>,
593 #[xmlserde(name = b"ref", ty = "attr")]
594 pub reference: StRef,
595 #[xmlserde(name = b"authorId", ty = "attr")]
596 pub author_id: u32,
597 #[xmlserde(name = b"shapeId", ty = "attr")]
598 pub shape_id: Option<u32>,
599 #[xmlserde(name = b"xr:uid", ty = "attr")]
600 pub guid: Option<String>,
601}
602
603#[derive(Debug, XmlSerialize, XmlDeserialize)]
604pub struct CtCommentList {
605 #[xmlserde(name = b"comment", ty = "child")]
606 pub comments: Vec<CtComment>,
607}
608
609#[derive(Debug, XmlSerialize, XmlDeserialize)]
610pub struct CtAuthors {
611 #[xmlserde(name = b"author", ty = "child")]
612 pub authors: Vec<PlainTextString>,
613}
614
615#[derive(Debug, XmlSerialize, XmlDeserialize)]
616pub struct CtObjectAnchor {
617 #[xmlserde(name = b"moveWithCells", ty = "attr", default = "default_false")]
618 pub move_with_cells: bool,
619 #[xmlserde(name = b"sizeWithCells", ty = "attr", default = "default_false")]
620 pub size_with_cells: bool,
621 #[xmlserde(name = b"from", ty = "child")]
622 pub from: CtMarker,
623 #[xmlserde(name = b"to", ty = "child")]
624 pub to: CtMarker,
625}
626
627#[derive(Debug, XmlSerialize, XmlDeserialize)]
628pub struct CtMarker {
629 #[xmlserde(name = b"xdr:col", ty = "child")]
630 pub col: PlainTextU32,
631 #[xmlserde(name = b"xdr:colOff", ty = "child")]
632 pub col_off: PlainTextU32,
633 #[xmlserde(name = b"xdr:row", ty = "child")]
634 pub row: PlainTextU32,
635 #[xmlserde(name = b"xdr:rowOff", ty = "child")]
636 pub row_off: PlainTextU32,
637}
638
639#[derive(Debug, XmlSerialize, XmlDeserialize)]
640pub struct CtCommentPr {
641 #[xmlserde(name = b"anchor", ty = "child")]
642 pub anchor: CtObjectAnchor,
643 #[xmlserde(name = b"locked", ty = "attr", default = "default_true")]
644 pub locked: bool,
645 #[xmlserde(name = b"default_size", ty = "attr", default = "default_true")]
646 pub default_size: bool,
647 #[xmlserde(name = b"print", ty = "attr", default = "default_true")]
648 pub print: bool,
649 #[xmlserde(name = b"disabled", ty = "attr", default = "default_false")]
650 pub disabled: bool,
651 #[xmlserde(name = b"autoFill", ty = "attr", default = "default_true")]
652 pub auto_fill: bool,
653 #[xmlserde(name = b"autoLine", ty = "attr", default = "default_true")]
654 pub auto_line: bool,
655 #[xmlserde(name = b"altText", ty = "attr")]
656 pub alt_text: Option<String>,
657 #[xmlserde(name = b"textHAlign", ty = "attr", default = "st_text_h_align_left")]
658 pub text_h_align: StTextHAlign,
659 #[xmlserde(name = b"textVAlign", ty = "attr", default = "st_text_v_align_top")]
660 pub text_v_align: StTextVAlign,
661 #[xmlserde(name = b"lockText", ty = "attr", default = "default_true")]
662 pub lock_text: bool,
663 #[xmlserde(name = b"justLastX", ty = "attr", default = "default_false")]
664 pub just_last_x: bool,
665 #[xmlserde(name = b"autoScale", ty = "attr", default = "default_false")]
666 pub auto_scale: bool,
667}
668
669#[derive(Debug, XmlSerialize, XmlDeserialize)]
670pub struct CtFileVersion {
671 #[xmlserde(name = b"appName", ty = "attr")]
672 pub app_name: Option<String>,
673 #[xmlserde(name = b"lastEdited", ty = "attr")]
674 pub last_edited: Option<String>,
675 #[xmlserde(name = b"lowestEdited", ty = "attr")]
676 pub lowest_edited: Option<String>,
677 #[xmlserde(name = b"rupBuild", ty = "attr")]
678 pub rup_build: Option<String>,
679 #[xmlserde(name = b"codeName", ty = "attr")]
680 pub code_name: Option<String>,
681}
682
683#[derive(Debug, XmlSerialize, XmlDeserialize)]
684pub struct CtDefinedNames {
685 #[xmlserde(name = b"definedName", ty = "child")]
686 pub names: Vec<CtDefinedName>,
687}
688
689#[derive(Debug, XmlSerialize, XmlDeserialize)]
690pub struct CtDefinedName {
691 #[xmlserde(name = b"name", ty = "attr")]
692 pub name: String,
693 #[xmlserde(name = b"comment", ty = "attr")]
694 pub comment: Option<String>,
695 #[xmlserde(name = b"commentMenu", ty = "attr")]
696 pub comment_menu: Option<String>,
697 #[xmlserde(name = b"description", ty = "attr")]
698 pub description: Option<String>,
699 #[xmlserde(name = b"help", ty = "attr")]
700 pub help: Option<String>,
701 #[xmlserde(name = b"statusBar", ty = "attr")]
702 pub status_bar: Option<String>,
703 #[xmlserde(name = b"localSheetId", ty = "attr")]
704 pub local_sheet_id: Option<u32>,
705 #[xmlserde(name = b"hidden", ty = "attr", default = "default_false")]
706 pub hidden: bool,
707 #[xmlserde(name = b"function", ty = "attr", default = "default_false")]
708 pub function: bool,
709 #[xmlserde(name = b"vbProcedure", ty = "attr", default = "default_false")]
710 pub vb_procedure: bool,
711 #[xmlserde(name = b"xlm", ty = "attr", default = "default_false")]
712 pub xlm: bool,
713 #[xmlserde(name = b"functionGroupId", ty = "attr")]
714 pub function_group_id: Option<u32>,
715 #[xmlserde(name = b"shortcutKey", ty = "attr")]
716 pub shortcut_key: Option<String>,
717 #[xmlserde(name = b"publishToServer", ty = "attr", default = "default_false")]
718 pub publish_to_server: bool,
719 #[xmlserde(name = b"workbookParameter", ty = "attr", default = "default_false")]
720 pub workbook_parameter: bool,
721}
722
723#[derive(Debug, XmlSerialize, XmlDeserialize)]
724pub struct CtFileRecoveryPr {
725 #[xmlserde(name = b"autoRecover", ty = "attr", default = "default_true")]
726 pub auto_recover: bool,
727 #[xmlserde(name = b"crashSave", ty = "attr", default = "default_false")]
728 pub crash_save: bool,
729 #[xmlserde(name = b"dataExtractLoad", ty = "attr", default = "default_false")]
730 pub data_extract_load: bool,
731 #[xmlserde(name = b"repairLoad", ty = "attr", default = "default_false")]
732 pub repair_load: bool,
733}
734
735#[derive(Debug, XmlSerialize, XmlDeserialize)]
736pub struct CtCalcPr {
737 #[xmlserde(name = b"calcId", ty = "attr")]
738 pub calc_id: u32,
739 #[xmlserde(name = b"calcMode", ty = "attr", default = "st_calc_mode_auto")]
740 pub calc_mode: StCalcMode,
741 #[xmlserde(name = b"fullCalcOnLoad", ty = "attr", default = "default_false")]
742 pub full_calc_on_load: bool,
743 #[xmlserde(name = b"refMode", ty = "attr", default = "st_ref_mode_a1")]
744 pub ref_mode: StRefMode,
745 #[xmlserde(name = b"iterate", ty = "attr", default = "default_false")]
746 pub iterate: bool,
747 #[xmlserde(name = b"iterateCount", ty = "attr", default = "default_100_u32")]
748 pub iterate_count: u32,
749 #[xmlserde(name = b"iterateDelta", ty = "attr", default = "default_iterate_delta")]
750 pub iterate_delta: f64,
751 #[xmlserde(name = b"fullPrecision", ty = "attr", default = "default_true")]
752 pub full_precision: bool,
753 #[xmlserde(name = b"calcCompleted", ty = "attr", default = "default_true")]
754 pub calc_completed: bool,
755 #[xmlserde(name = b"calcOnSave", ty = "attr", default = "default_true")]
756 pub calc_on_save: bool,
757 #[xmlserde(name = b"concurrentCalc", ty = "attr", default = "default_true")]
758 pub concurrent_calc: bool,
759 #[xmlserde(name = b"concurrentManualCount", ty = "attr", default = "default_true")]
760 pub concurrent_manual_calc: bool,
761 #[xmlserde(name = b"forceFullCalc", ty = "attr")]
762 pub force_full_calc: Option<bool>,
763}
764
765#[derive(Debug, XmlDeserialize, XmlSerialize)]
766pub struct CtSmartTagPr {
767 #[xmlserde(name = b"embed", ty = "attr", default = "default_false")]
768 pub embed: bool,
769 #[xmlserde(name = b"show", ty = "attr", default = "st_smart_tag_show_all")]
770 pub show: StSmartTagShow,
771}
772
773#[derive(Debug, XmlDeserialize, XmlSerialize)]
774pub struct CtWorkbookPr {
775 #[xmlserde(name = b"date1904", ty = "attr", default = "default_false")]
776 pub date1904: bool,
777 #[xmlserde(name = b"showObjects", ty = "attr", default = "st_objects_all")]
778 pub show_objects: StObjects,
779 #[xmlserde(
780 name = b"showBorderUnselectedTables",
781 ty = "attr",
782 default = "default_true"
783 )]
784 pub show_border_unselected_tables: bool,
785 #[xmlserde(name = b"filterPrivacy", ty = "attr", default = "default_false")]
786 pub filter_privacy: bool,
787 #[xmlserde(name = b"promptedSolutions", ty = "attr", default = "default_false")]
788 pub prompted_solutions: bool,
789 #[xmlserde(name = b"showInkASnnotation", ty = "attr", default = "default_true")]
790 pub show_ink_annotation: bool,
791 #[xmlserde(name = b"backupFile", ty = "attr", default = "default_false")]
792 pub backup_file: bool,
793 #[xmlserde(
794 name = b"saveExternalLinkValues",
795 ty = "attr",
796 default = "default_true"
797 )]
798 pub save_external_link_values: bool,
799 #[xmlserde(name = b"updateLinks", ty = "attr", default = "st_update_links")]
800 pub update_links: StUpdateLinks,
801 #[xmlserde(name = b"codeName", ty = "attr")]
802 pub code_name: Option<String>,
803 #[xmlserde(name = b"hidePivotFieldList", ty = "attr", default = "default_false")]
804 pub hide_pivot_field_list: bool,
805 #[xmlserde(name = b"showPivotChartFilter", ty = "attr", default = "default_false")]
806 pub show_pivot_chart_filter: bool,
807 #[xmlserde(name = b"allowRefreshQuery", ty = "attr", default = "default_false")]
808 pub allow_refresh_query: bool,
809 #[xmlserde(name = b"publish_items", ty = "attr", default = "default_false")]
810 pub publish_items: bool,
811 #[xmlserde(name = b"checkCompatibility", ty = "attr", default = "default_false")]
812 pub check_compatibility: bool,
813 #[xmlserde(
814 name = b"auto_compress_pictures",
815 ty = "attr",
816 default = "default_true"
817 )]
818 pub auto_compress_pictures: bool,
819 #[xmlserde(name = b"refreshAllConnections", ty = "attr", default = "default_true")]
820 pub refresh_all_connections: bool,
821 #[xmlserde(name = b"defaultThemeVersion", ty = "attr")]
822 pub default_theme_version: Option<u32>,
823}
824
825#[derive(Debug, XmlDeserialize, XmlSerialize)]
826pub struct CtWorkbookProtection {
827 #[xmlserde(name = b"lockStructure", ty = "attr", default = "default_false")]
828 pub lock_structure: bool,
829 #[xmlserde(name = b"lockWindows", ty = "attr", default = "default_false")]
830 pub lock_windows: bool,
831 #[xmlserde(name = b"lockVersion", ty = "attr", default = "default_false")]
832 pub lock_version: bool,
833 #[xmlserde(name = b"revisionsAlgorithmName", ty = "attr")]
834 pub revisions_algorithm_name: Option<String>,
835 #[xmlserde(name = b"revisionsHashValue", ty = "attr")]
836 pub revisions_hash_value: Option<String>,
837 #[xmlserde(name = b"revisionsSaltValue", ty = "attr")]
838 pub revisions_salt_value: Option<String>,
839 #[xmlserde(name = b"revisionsSpinCount", ty = "attr")]
840 pub revisions_spin_count: Option<u32>,
841 #[xmlserde(name = b"workbookAlgorithmName", ty = "attr")]
842 pub workbook_algorithm_name: Option<String>,
843 #[xmlserde(name = b"workbookHashValue", ty = "attr")]
844 pub workbook_hash_value: Option<String>,
845 #[xmlserde(name = b"workbookSaltValue", ty = "attr")]
846 pub workbook_salt_value: Option<String>,
847 #[xmlserde(name = b"workbookSpinCount", ty = "attr")]
848 pub workbook_spin_count: Option<u32>,
849}
850
851#[derive(Debug, XmlDeserialize, XmlSerialize)]
852pub struct CtWebPublishing {
853 #[xmlserde(name = b"css", ty = "attr", default = "default_true")]
854 pub css: bool,
855 #[xmlserde(name = b"ticket", ty = "attr", default = "default_true")]
856 pub ticket: bool,
857 #[xmlserde(name = b"logFileNames", ty = "attr", default = "default_true")]
858 pub long_file_names: bool,
859 #[xmlserde(name = b"vml", ty = "attr", default = "default_false")]
860 pub vml: bool,
861 #[xmlserde(name = b"allowPng", ty = "attr", default = "default_false")]
862 pub allow_png: bool,
863 #[xmlserde(
864 name = b"targetScreenSize",
865 ty = "attr",
866 default = "default_screen_size"
867 )]
868 pub target_screen_size: StTargetScreenSize,
869 #[xmlserde(name = b"dpi", ty = "attr", default = "default_dpi")]
870 pub dpi: u32,
871 #[xmlserde(name = b"characterSet", ty = "attr")]
872 pub character_set: Option<String>,
873}
874
875#[derive(Debug, XmlDeserialize, XmlSerialize)]
876pub struct CtOleSize {
877 #[xmlserde(name = b"ref", ty = "attr")]
878 pub reference: StRef,
879}
880
881#[derive(Debug, XmlDeserialize, XmlSerialize)]
882pub struct CtPivotCaches {
883 #[xmlserde(name = b"pivot_cache", ty = "child")]
884 pub pivot_caches: Vec<CtPivotCache>,
885}
886
887#[derive(Debug, XmlDeserialize, XmlSerialize)]
888pub struct CtPivotCache {
889 #[xmlserde(name = b"cacheId", ty = "attr")]
890 pub cache_id: u32,
891 #[xmlserde(name = b"r:id", ty = "attr")]
892 pub id: String,
893}
894
895#[derive(Debug, XmlDeserialize, XmlSerialize)]
896pub struct CtFileSharing {
897 #[xmlserde(name = b"readOnlyRecommended", ty = "attr", default = "default_false")]
898 pub read_only_recommended: bool,
899 #[xmlserde(name = b"userName", ty = "attr")]
900 pub user_name: String,
901 #[xmlserde(name = b"algorithmName", ty = "attr")]
902 pub algorithm_name: Option<String>,
903 #[xmlserde(name = b"hashValue", ty = "attr")]
904 pub hash_value: Option<String>,
905 #[xmlserde(name = b"saltValue", ty = "attr")]
906 pub salt_value: Option<String>,
907 #[xmlserde(name = b"spinCount", ty = "attr")]
908 pub spin_count: Option<u32>,
909}
910
911#[derive(Debug, XmlDeserialize, XmlSerialize)]
912pub struct CtSmartTagTypes {
913 #[xmlserde(name = b"smartTagType", ty = "child")]
914 pub smart_tag_types: Vec<CtSmartTagType>,
915}
916
917#[derive(Debug, XmlDeserialize, XmlSerialize)]
918pub struct CtSmartTagType {
919 #[xmlserde(name = b"namespaceUri", ty = "attr")]
920 pub namespace_uri: Option<String>,
921 #[xmlserde(name = b"name", ty = "attr")]
922 pub name: Option<String>,
923 #[xmlserde(name = b"url", ty = "attr")]
924 pub url: Option<String>,
925}
926
927#[derive(Debug, XmlDeserialize, XmlSerialize)]
928pub struct CtExternalReferences {
929 #[xmlserde(name = b"externalReference", ty = "child")]
930 pub external_references: Vec<CtExternalReference>,
931}
932
933#[derive(Debug, XmlDeserialize, XmlSerialize)]
934pub struct CtExternalReference {
935 #[xmlserde(name = b"r:id", ty = "attr")]
936 pub id: String,
937}
938
939#[derive(Debug, XmlDeserialize, XmlSerialize)]
940pub struct CtWebPublishObjects {
941 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
942 pub count: u32,
943 #[xmlserde(name = b"webPublishObject", ty = "child", vec_size = "count")]
944 pub web_publish_objects: Vec<CtWebPublishObject>,
945}
946
947#[derive(Debug, XmlDeserialize, XmlSerialize)]
948pub struct CtWebPublishObject {
949 #[xmlserde(name = b"id", ty = "attr")]
950 pub id: u32,
951 #[xmlserde(name = b"divId", ty = "attr")]
952 pub div_id: String,
953 #[xmlserde(name = b"sourceObject", ty = "attr")]
954 pub source_object: Option<String>,
955 #[xmlserde(name = b"destinationFile", ty = "attr")]
956 pub destination_file: String,
957 #[xmlserde(name = b"title", ty = "attr")]
958 pub title: Option<String>,
959 #[xmlserde(name = b"autoRepublish", ty = "attr", default = "default_false")]
960 pub auto_republish: bool,
961}
962
963#[derive(Debug, XmlDeserialize, XmlSerialize)]
964pub struct CtFunctionGroups {
965 #[xmlserde(name = b"functionGroup", ty = "child")]
966 pub function_groups: Vec<CtFunctionGroup>,
967 #[xmlserde(
968 name = b"buildInGroupCount",
969 ty = "attr",
970 default = "default_built_in_group_count"
971 )]
972 pub built_in_group_count: u32,
973}
974
975#[derive(Debug, XmlDeserialize, XmlSerialize)]
976pub struct CtFunctionGroup {
977 #[xmlserde(name = b"name", ty = "attr")]
978 pub name: String,
979}
980
981#[derive(Debug, XmlDeserialize, XmlSerialize)]
982pub struct CtBookViews {
983 #[xmlserde(name = b"workbookView", ty = "child")]
984 pub views: Vec<CtBookView>,
985}
986
987#[derive(Debug, XmlDeserialize, XmlSerialize)]
988pub struct CtBookView {
989 #[xmlserde(name = b"visibility", ty = "attr", default = "st_visibility_visible")]
990 pub visibility: StVisibility,
991 #[xmlserde(name = b"minimized", ty = "attr", default = "default_false")]
992 pub minimized: bool,
993 #[xmlserde(name = b"showHorizontalScroll", ty = "attr", default = "default_true")]
994 pub show_horizontal_scroll: bool,
995 #[xmlserde(name = b"showVerticalScroll", ty = "attr", default = "default_true")]
996 pub show_vertical_scroll: bool,
997 #[xmlserde(name = b"showSheetTabs", ty = "attr", default = "default_true")]
998 pub show_sheet_tabs: bool,
999 #[xmlserde(name = b"xWindow", ty = "attr")]
1000 pub x_window: Option<i32>,
1001 #[xmlserde(name = b"yWindow", ty = "attr")]
1002 pub y_window: Option<i32>,
1003 #[xmlserde(name = b"windowWidth", ty = "attr")]
1004 pub window_width: Option<u32>,
1005 #[xmlserde(name = b"windowHeight", ty = "attr")]
1006 pub window_height: Option<u32>,
1007 #[xmlserde(name = b"tabRatio", ty = "attr", default = "default_tab_ratio")]
1008 pub tab_ratio: u32,
1009 #[xmlserde(name = b"firstSheet", ty = "attr", default = "default_zero_u32")]
1010 pub first_sheet: u32,
1011 #[xmlserde(name = b"activeTab", ty = "attr", default = "default_zero_u32")]
1012 pub active_tab: u32,
1013 #[xmlserde(
1014 name = b"autoFilterDateGrouping",
1015 ty = "attr",
1016 default = "default_true"
1017 )]
1018 pub auto_filter_date_grouping: bool,
1019}
1020
1021#[derive(Debug, XmlDeserialize, XmlSerialize)]
1022pub struct CtCustomWorkbookViews {
1023 #[xmlserde(name = b"customWorkbookView", ty = "child")]
1024 pub custom_workbook_views: Vec<CtCustomWorkbookView>,
1025}
1026
1027#[derive(Debug, XmlDeserialize, XmlSerialize)]
1028pub struct CtCustomWorkbookView {
1029 #[xmlserde(name = b"name", ty = "attr")]
1030 pub name: String,
1031 #[xmlserde(name = b"guid", ty = "attr")]
1032 pub guid: String,
1033 #[xmlserde(name = b"autoUpdate", ty = "attr", default = "default_false")]
1034 pub auto_update: bool,
1035 #[xmlserde(name = b"mergeInterval", ty = "attr")]
1036 pub merge_interval: Option<u32>,
1037 #[xmlserde(name = b"changesSavedWin", ty = "attr", default = "default_false")]
1038 pub changes_saved_win: bool,
1039 #[xmlserde(name = b"onlySync", ty = "attr", default = "default_false")]
1040 pub only_sync: bool,
1041 #[xmlserde(name = b"personal_view", ty = "attr", default = "default_false")]
1042 pub personal_view: bool,
1043 #[xmlserde(name = b"includePrintSettings", ty = "attr", default = "default_true")]
1044 pub include_print_settings: bool,
1045 #[xmlserde(name = b"includeHiddenRowCol", ty = "attr", default = "default_true")]
1046 pub include_hidden_row_col: bool,
1047 #[xmlserde(name = b"maximized", ty = "attr", default = "default_false")]
1048 pub maximized: bool,
1049 #[xmlserde(name = b"minimized", ty = "attr", default = "default_false")]
1050 pub minimized: bool,
1051 #[xmlserde(name = b"showHorizontalScroll", ty = "attr", default = "default_true")]
1052 pub show_horizontal_scroll: bool,
1053 #[xmlserde(name = b"showVerticalScroll", ty = "attr", default = "default_true")]
1054 pub show_vertical_scroll: bool,
1055 #[xmlserde(name = b"showSheetTabs", ty = "attr", default = "default_true")]
1056 pub show_sheet_tabs: bool,
1057 #[xmlserde(name = b"xWindow", ty = "attr")]
1058 pub x_window: Option<i32>,
1059 #[xmlserde(name = b"yWindow", ty = "attr")]
1060 pub y_window: Option<i32>,
1061 #[xmlserde(name = b"windowWidth", ty = "attr")]
1062 pub window_width: u32,
1063 #[xmlserde(name = b"windowHeight", ty = "attr")]
1064 pub window_height: u32,
1065 #[xmlserde(name = b"tabRatio", ty = "attr", default = "default_tab_ratio")]
1066 pub tab_ratio: u32,
1067 #[xmlserde(name = b"activeSheetId", ty = "attr")]
1068 pub active_sheet_id: u32,
1069 #[xmlserde(name = b"showFormulaBar", ty = "attr", default = "default_true")]
1070 pub show_formula_bar: bool,
1071 #[xmlserde(name = b"showStatusBar", ty = "attr", default = "default_true")]
1072 pub show_statusbar: bool,
1073 #[xmlserde(
1074 name = b"showComments",
1075 ty = "attr",
1076 default = "st_comments_comm_indicator"
1077 )]
1078 pub show_comments: StComments,
1079 #[xmlserde(name = b"showObjects", ty = "attr", default = "st_objects_all")]
1080 pub show_objects: StObjects,
1081}
1082
1083#[derive(Debug, XmlSerialize, XmlDeserialize)]
1084pub struct CtSheets {
1085 #[xmlserde(name = b"sheet", ty = "child")]
1086 pub sheets: Vec<CtSheet>,
1087}
1088
1089#[derive(Debug, XmlSerialize, XmlDeserialize)]
1090pub struct CtSheet {
1091 #[xmlserde(name = b"name", ty = "attr")]
1092 pub name: String,
1093 #[xmlserde(name = b"sheetId", ty = "attr")]
1094 pub sheet_id: u32,
1095 #[xmlserde(name = b"state", ty = "attr", default = "st_sheet_state_visible")]
1096 pub state: StSheetState,
1097 #[xmlserde(name = b"r:id", ty = "attr")]
1098 pub id: String,
1099}
1100
1101#[derive(Debug, XmlSerialize, XmlDeserialize)]
1102pub struct CtSheetPr {
1103 #[xmlserde(name = b"tabColor", ty = "child")]
1104 pub tab_color: Option<CtColor>,
1105 #[xmlserde(name = b"outlinePr", ty = "child")]
1106 pub outline_pr: Option<CtOutlinePr>,
1107 #[xmlserde(name = b"pageSetupPr", ty = "child")]
1108 pub page_setup_pr: Option<CtPageSetupPr>,
1109 #[xmlserde(name = b"syncHorizontal", ty = "attr", default = "default_false")]
1110 pub sync_horizontal: bool,
1111 #[xmlserde(name = b"syncVertical", ty = "attr", default = "default_false")]
1112 pub sync_vertical: bool,
1113 #[xmlserde(name = b"syncRef", ty = "attr")]
1114 pub sync_ref: Option<StRef>,
1115 #[xmlserde(name = b"transitionEvaluation", ty = "attr", default = "default_false")]
1116 pub transition_evaluation: bool,
1117 #[xmlserde(name = b"transitionEntry", ty = "attr", default = "default_false")]
1118 pub transition_entry: bool,
1119 #[xmlserde(name = b"published", ty = "attr", default = "default_true")]
1120 pub published: bool,
1121 #[xmlserde(name = b"codeName", ty = "attr")]
1122 pub code_name: Option<String>,
1123 #[xmlserde(name = b"filterMode", ty = "attr", default = "default_false")]
1124 pub filter_mode: bool,
1125 #[xmlserde(
1126 name = b"enableFormatConditionsCalculation",
1127 ty = "attr",
1128 default = "default_true"
1129 )]
1130 pub enable_format_conditions_calculation: bool,
1131}
1132
1133#[derive(Debug, XmlSerialize, XmlDeserialize)]
1134pub struct CtOutlinePr {
1135 #[xmlserde(name = b"applyStyles", ty = "attr", default = "default_false")]
1136 pub apply_styles: bool,
1137 #[xmlserde(name = b"summaryBelow", ty = "attr", default = "default_true")]
1138 pub summary_below: bool,
1139 #[xmlserde(name = b"summaryRight", ty = "attr", default = "default_true")]
1140 pub summary_right: bool,
1141 #[xmlserde(name = b"showOutlineSymbols", ty = "attr", default = "default_true")]
1142 pub show_outline_symbols: bool,
1143}
1144
1145#[derive(Debug, XmlSerialize, XmlDeserialize)]
1146pub struct CtPageSetupPr {
1147 #[xmlserde(name = b"autoPageBreaks", ty = "attr", default = "default_true")]
1148 pub auto_page_breaks: bool,
1149 #[xmlserde(name = b"fitToPage", ty = "attr", default = "default_false")]
1150 pub fit_to_page: bool,
1151}
1152
1153#[derive(Debug, XmlSerialize, XmlDeserialize)]
1154pub struct CtSheetDimension {
1155 #[xmlserde(name = b"ref", ty = "attr")]
1156 pub reference: StRef,
1157}
1158
1159#[derive(Debug, XmlSerialize, XmlDeserialize)]
1160pub struct CtSheetViews {
1161 #[xmlserde(name = b"sheetView", ty = "child")]
1162 pub sheet_views: Vec<CtSheetView>,
1163}
1164
1165#[derive(Debug, XmlSerialize, XmlDeserialize)]
1166pub struct CtSheetView {
1167 #[xmlserde(name = b"pane", ty = "child")]
1168 pub pane: Option<CtPane>,
1169 #[xmlserde(name = b"selection", ty = "child")]
1170 pub selection: Vec<CtSelection>, #[xmlserde(name = b"pivotSelection", ty = "child")]
1172 pub pivot_selection: Vec<CtPivotSelection>, #[xmlserde(name = b"windowProtection", ty = "attr", default = "default_false")]
1174 pub window_protection: bool,
1175 #[xmlserde(name = b"showFormulas", ty = "attr", default = "default_false")]
1176 pub show_formulas: bool,
1177 #[xmlserde(name = b"showGridLines", ty = "attr", default = "default_true")]
1178 pub show_grid_lines: bool,
1179 #[xmlserde(name = b"showRowColHeaders", ty = "attr", default = "default_true")]
1180 pub show_row_col_headers: bool,
1181 #[xmlserde(name = b"showZeros", ty = "attr", default = "default_true")]
1182 pub show_zeros: bool,
1183 #[xmlserde(name = b"rightToLeft", ty = "attr", default = "default_false")]
1184 pub right_to_left: bool,
1185 #[xmlserde(name = b"tabSelected", ty = "attr", default = "default_false")]
1186 pub tab_selected: bool,
1187 #[xmlserde(name = b"showRuler", ty = "attr", default = "default_true")]
1188 pub show_ruler: bool,
1189 #[xmlserde(name = b"showOutlineSymbols", ty = "attr", default = "default_true")]
1190 pub show_outline_symbols: bool,
1191 #[xmlserde(name = b"defaultGridColor", ty = "attr", default = "default_true")]
1192 pub default_grid_color: bool,
1193 #[xmlserde(name = b"showWhiteSpace", ty = "attr", default = "default_true")]
1194 pub show_white_space: bool,
1195 #[xmlserde(name = b"view", ty = "attr", default = "st_sheet_view_type_normal")]
1196 pub view: StSheetViewType,
1197 #[xmlserde(name = b"topLeftCell", ty = "attr")]
1198 pub top_left_cell: Option<StCellRef>,
1199 #[xmlserde(name = b"colorId", ty = "attr", default = "default_color_id")]
1200 pub color_id: u32,
1201 #[xmlserde(name = b"zoomScale", ty = "attr", default = "default_100_u32")]
1202 pub zoom_scale: u32,
1203 #[xmlserde(name = b"zoomScaleNormal", ty = "attr", default = "default_zero_u32")]
1204 pub zoom_scale_normal: u32,
1205 #[xmlserde(
1206 name = b"zoomScaleSheetLayoutView",
1207 ty = "attr",
1208 default = "default_zero_u32"
1209 )]
1210 pub zoom_scale_sheet_layout_view: u32,
1211 #[xmlserde(
1212 name = b"zoomScalePageLayoutView",
1213 ty = "attr",
1214 default = "default_zero_u32"
1215 )]
1216 pub zoom_scale_page_layout_view: u32,
1217 #[xmlserde(name = b"workbookViewId", ty = "attr")]
1218 pub workbook_view_id: u32,
1219}
1220
1221#[derive(Debug, XmlSerialize, XmlDeserialize)]
1222pub struct CtPane {
1223 #[xmlserde(name = b"xSplit", ty = "attr", default = "default_zero_f64")]
1224 pub x_split: f64,
1225 #[xmlserde(name = b"ySplit", ty = "attr", default = "default_zero_f64")]
1226 pub y_split: f64,
1227 #[xmlserde(name = b"topLeftCell", ty = "attr")]
1228 pub top_left_cell: Option<StCellRef>,
1229 #[xmlserde(name = b"activePane", ty = "attr", default = "st_pane_top_left")]
1230 pub active_pane: StPane,
1231 #[xmlserde(name = b"state", ty = "attr", default = "st_pane_state_split")]
1232 pub state: StPaneState,
1233}
1234
1235#[derive(Debug, XmlSerialize, XmlDeserialize)]
1236pub struct CtSelection {
1237 #[xmlserde(name = b"pane", ty = "attr", default = "st_pane_top_left")]
1238 pub pane: StPane,
1239 #[xmlserde(name = b"activeCell", ty = "attr")]
1240 pub active_cell: Option<StCellRef>,
1241 #[xmlserde(name = b"activeCellId", ty = "attr", default = "default_zero_u32")]
1242 pub active_cell_id: u32,
1243 #[xmlserde(name = b"sqref", ty = "attr")]
1244 pub sqref: Option<String>, }
1246
1247#[derive(Debug, XmlSerialize, XmlDeserialize)]
1248pub struct CtPivotSelection {
1249 #[xmlserde(name = b"pivotArea", ty = "child")]
1250 pub pivot_area: CtPivotArea,
1251 #[xmlserde(name = b"pane", ty = "attr", default = "st_pane_top_left")]
1252 pub pane: StPane,
1253 #[xmlserde(name = b"showHeader", ty = "attr", default = "default_false")]
1254 pub show_header: bool,
1255 #[xmlserde(name = b"label", ty = "attr", default = "default_false")]
1256 pub label: bool,
1257 #[xmlserde(name = b"data", ty = "attr", default = "default_false")]
1258 pub data: bool,
1259 #[xmlserde(name = b"extendable", ty = "attr", default = "default_false")]
1260 pub extendable: bool,
1261 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
1262 pub count: u32,
1263 #[xmlserde(name = b"axis", ty = "attr")]
1264 pub axis: Option<StAxis>,
1265 #[xmlserde(name = b"dimension", ty = "attr", default = "default_zero_u32")]
1266 pub dimension: u32,
1267 #[xmlserde(name = b"start", ty = "attr", default = "default_zero_u32")]
1268 pub start: u32,
1269 #[xmlserde(name = b"min", ty = "attr", default = "default_zero_u32")]
1270 pub min: u32,
1271 #[xmlserde(name = b"max", ty = "attr", default = "default_zero_u32")]
1272 pub max: u32,
1273 #[xmlserde(name = b"activeRow", ty = "attr", default = "default_zero_u32")]
1274 pub active_row: u32,
1275 #[xmlserde(name = b"activeCol", ty = "attr", default = "default_zero_u32")]
1276 pub active_col: u32,
1277 #[xmlserde(name = b"previousRow", ty = "attr", default = "default_zero_u32")]
1278 pub previous_row: u32,
1279 #[xmlserde(name = b"previousCol", ty = "attr", default = "default_zero_u32")]
1280 pub previous_col: u32,
1281 #[xmlserde(name = b"click", ty = "attr", default = "default_zero_u32")]
1282 pub click: u32,
1283 #[xmlserde(name = b"r:id", ty = "attr")]
1284 pub id: Option<String>,
1285}
1286
1287#[derive(Debug, XmlSerialize, XmlDeserialize)]
1288pub struct CtPivotArea {
1289 #[xmlserde(name = b"references", ty = "child")]
1290 pub references: Option<CtPivotAreaReferences>,
1291 #[xmlserde(name = b"field", ty = "attr")]
1292 pub field: Option<i32>,
1293 #[xmlserde(name = b"type", ty = "attr", default = "st_pivot_area_type_normal")]
1294 pub ty: StPivotAreaType,
1295 #[xmlserde(name = b"dataOnly", ty = "attr", default = "default_true")]
1296 pub data_only: bool,
1297 #[xmlserde(name = b"labelOnly", ty = "attr", default = "default_false")]
1298 pub label_only: bool,
1299 #[xmlserde(name = b"grandRow", ty = "attr", default = "default_false")]
1300 pub grand_row: bool,
1301 #[xmlserde(name = b"grandCol", ty = "attr", default = "default_false")]
1302 pub grand_col: bool,
1303 #[xmlserde(name = b"cacheIndex", ty = "attr", default = "default_false")]
1304 pub cache_index: bool,
1305 #[xmlserde(name = b"outline", ty = "attr", default = "default_true")]
1306 pub outline: bool,
1307 #[xmlserde(name = b"offset", ty = "attr")]
1308 pub offset: StRef,
1309 #[xmlserde(
1310 name = b"collapsedLevelAreSubtotals",
1311 ty = "attr",
1312 default = "default_true"
1313 )]
1314 pub collapsed_level_are_subtotals: bool,
1315 #[xmlserde(name = b"axis", ty = "attr")]
1316 pub axis: Option<StAxis>,
1317 #[xmlserde(name = b"fieldPosition", ty = "attr")]
1318 pub field_position: Option<u32>,
1319}
1320
1321#[derive(Debug, XmlSerialize, XmlDeserialize)]
1322pub struct CtPivotAreaReferences {
1323 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
1324 pub count: u32,
1325 #[xmlserde(name = b"reference", ty = "child")]
1326 pub references: Vec<CtPivotAreaReference>,
1327}
1328
1329#[derive(Debug, XmlSerialize, XmlDeserialize)]
1330pub struct CtPivotAreaReference {
1331 #[xmlserde(name = b"x", ty = "child", vec_size = "count")]
1332 pub xs: Vec<CtIndex>,
1333 #[xmlserde(name = b"field", ty = "attr")]
1334 pub field: Option<u32>,
1335 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
1336 pub count: u32,
1337 #[xmlserde(name = b"selected", ty = "attr", default = "default_true")]
1338 pub selected: bool,
1339 #[xmlserde(name = b"byPosition", ty = "attr", default = "default_false")]
1340 pub by_position: bool,
1341 #[xmlserde(name = b"relative", ty = "attr", default = "default_false")]
1342 pub relative: bool,
1343 #[xmlserde(name = b"defaultSubtotal", ty = "attr", default = "default_false")]
1344 pub default_subtotal: bool,
1345 #[xmlserde(name = b"sumSubtotal", ty = "attr", default = "default_false")]
1346 pub sum_subtotal: bool,
1347 #[xmlserde(name = b"countASubtotal", ty = "attr", default = "default_false")]
1348 pub count_a_subtotal: bool,
1349 #[xmlserde(name = b"avgSubtotal", ty = "attr", default = "default_false")]
1350 pub avg_subtotal: bool,
1351 #[xmlserde(name = b"maxSubtotal", ty = "attr", default = "default_false")]
1352 pub max_subtotal: bool,
1353 #[xmlserde(name = b"minSubtotal", ty = "attr", default = "default_false")]
1354 pub min_subtotal: bool,
1355 #[xmlserde(name = b"productSubtotal", ty = "attr", default = "default_false")]
1356 pub product_subtotal: bool,
1357 #[xmlserde(name = b"countSubtotal", ty = "attr", default = "default_false")]
1358 pub count_subtotal: bool,
1359 #[xmlserde(name = b"stdDevSubtotal", ty = "attr", default = "default_false")]
1360 pub std_dev_subtotal: bool,
1361 #[xmlserde(name = b"stdDevPSubtotal", ty = "attr", default = "default_false")]
1362 pub std_dev_p_subtotal: bool,
1363 #[xmlserde(name = b"stdVarSubtotal", ty = "attr", default = "default_false")]
1364 pub std_var_subtotal: bool,
1365 #[xmlserde(name = b"stdVarPSubtotal", ty = "attr", default = "default_false")]
1366 pub std_var_p_subtotal: bool,
1367}
1368
1369#[derive(Debug, XmlSerialize, XmlDeserialize)]
1370pub struct CtIndex {
1371 #[xmlserde(name = b"v", ty = "attr")]
1372 pub v: u32,
1373}
1374
1375#[derive(Debug, XmlSerialize, XmlDeserialize)]
1376pub struct CtSheetCalcPr {
1377 #[xmlserde(name = b"fullCalcOnLoad", ty = "attr", default = "default_false")]
1378 pub full_calc_on_load: bool,
1379}
1380
1381#[derive(Debug, XmlSerialize, XmlDeserialize, Clone)]
1382pub struct CtSheetFormatPr {
1383 #[xmlserde(name = b"baseColWidth", ty = "attr", default = "default_8_u32")]
1384 pub base_col_width: u32,
1385 #[xmlserde(name = b"defaultColWidth", ty = "attr")]
1386 pub default_col_width: Option<f64>,
1387 #[xmlserde(name = b"defaultRowHeight", ty = "attr")]
1388 pub default_row_height: f64,
1389 #[xmlserde(name = b"customHeight", ty = "attr", default = "default_false")]
1390 pub custom_height: bool,
1391 #[xmlserde(name = b"zeroHeight", ty = "attr", default = "default_false")]
1392 pub zero_height: bool,
1393 #[xmlserde(name = b"thickTop", ty = "attr", default = "default_false")]
1394 pub thick_top: bool,
1395 #[xmlserde(name = b"thickBottom", ty = "attr", default = "default_false")]
1396 pub thick_bottom: bool,
1397 #[xmlserde(name = b"outlineLevelRow", ty = "attr", default = "default_zero_u32")]
1398 pub outline_level_row: u32,
1399 #[xmlserde(name = b"outlineLevelCol", ty = "attr", default = "default_zero_u32")]
1400 pub outline_level_col: u32,
1401}
1402
1403#[derive(Debug, XmlSerialize, XmlDeserialize)]
1404pub struct CtCols {
1405 #[xmlserde(name = b"col", ty = "child")]
1406 pub cols: Vec<CtCol>,
1407}
1408
1409#[derive(Debug, XmlSerialize, XmlDeserialize)]
1410pub struct CtCol {
1411 #[xmlserde(name = b"min", ty = "attr")]
1412 pub min: u32,
1413 #[xmlserde(name = b"max", ty = "attr")]
1414 pub max: u32,
1415 #[xmlserde(name = b"width", ty = "attr")]
1416 pub width: Option<f64>,
1417 #[xmlserde(name = b"style", ty = "attr", default = "default_zero_u32")]
1418 pub style: u32,
1419 #[xmlserde(name = b"hidden", ty = "attr", default = "default_false")]
1420 pub hidden: bool,
1421 #[xmlserde(name = b"bestFit", ty = "attr", default = "default_false")]
1422 pub best_fit: bool,
1423 #[xmlserde(name = b"customWidth", ty = "attr", default = "default_false")]
1424 pub custom_width: bool,
1425 #[xmlserde(name = b"phonetic", ty = "attr", default = "default_false")]
1426 pub phonetic: bool,
1427 #[xmlserde(name = b"outlineLevel", ty = "attr", default = "default_zero_u32")]
1428 pub outline_level: u32,
1429 #[xmlserde(name = b"collapsed", ty = "attr", default = "default_false")]
1430 pub collapsed: bool,
1431}
1432
1433#[derive(Debug, XmlSerialize, XmlDeserialize)]
1434pub struct CtControls {
1435 #[xmlserde(name = b"control", ty = "child")]
1436 pub controls: Vec<CtControl>,
1437}
1438
1439#[derive(Debug, XmlSerialize, XmlDeserialize)]
1440pub struct CtControl {
1441 #[xmlserde(name = b"controlPr", ty = "child")]
1442 pub control_pr: Option<CtControlPr>,
1443 #[xmlserde(name = b"shapeId", ty = "attr")]
1444 pub shape_id: u32,
1445 #[xmlserde(name = b"r:id", ty = "attr")]
1446 pub id: String,
1447 #[xmlserde(name = b"name", ty = "attr")]
1448 pub name: Option<String>,
1449}
1450
1451#[derive(Debug, XmlSerialize, XmlDeserialize)]
1452pub struct CtControlPr {
1453 #[xmlserde(name = b"anchor", ty = "child")]
1454 pub anchor: CtObjectAnchor,
1455 #[xmlserde(name = b"locked", ty = "attr", default = "default_true")]
1456 pub locked: bool,
1457 #[xmlserde(name = b"defaultSize", ty = "attr", default = "default_true")]
1458 pub default_size: bool,
1459 #[xmlserde(name = b"print", ty = "attr", default = "default_true")]
1460 pub print: bool,
1461 #[xmlserde(name = b"disabled", ty = "attr", default = "default_false")]
1462 pub disabled: bool,
1463 #[xmlserde(name = b"recalcAlways", ty = "attr", default = "default_false")]
1464 pub recalc_always: bool,
1465 #[xmlserde(name = b"uiObject", ty = "attr", default = "default_false")]
1466 pub ui_object: bool,
1467 #[xmlserde(name = b"autoFill", ty = "attr", default = "default_true")]
1468 pub auto_fill: bool,
1469 #[xmlserde(name = b"autoLine", ty = "attr", default = "default_true")]
1470 pub auto_line: bool,
1471 #[xmlserde(name = b"autoPict", ty = "attr", default = "default_true")]
1472 pub auto_pict: bool,
1473 #[xmlserde(name = b"macro", ty = "attr")]
1474 pub macr: Option<StFormula>,
1475 #[xmlserde(name = b"altText", ty = "attr")]
1476 pub alt_text: Option<String>,
1477 #[xmlserde(name = b"linkedCell", ty = "attr")]
1478 pub linked_cell: Option<String>,
1479 #[xmlserde(name = b"listFillRange", ty = "attr")]
1480 pub list_fill_range: Option<String>,
1481 #[xmlserde(name = b"cf", ty = "attr", default = "default_string_pict")]
1482 pub cf: String,
1483 #[xmlserde(name = b"r:id", ty = "attr")]
1484 pub id: Option<String>,
1485}
1486
1487#[derive(Debug, XmlSerialize, XmlDeserialize)]
1488pub struct CtIgnoredError {
1489 #[xmlserde(name = b"sqref", ty = "attr")]
1490 pub sqref: String, #[xmlserde(name = b"evalError", ty = "attr", default = "default_false")]
1492 pub eval_error: bool,
1493 #[xmlserde(name = b"twoDigitTextYear", ty = "attr", default = "default_false")]
1494 pub two_digit_text_year: bool,
1495 #[xmlserde(name = b"numberStoredAsText", ty = "attr", default = "default_false")]
1496 pub number_stored_as_text: bool,
1497 #[xmlserde(name = b"formula", ty = "attr", default = "default_false")]
1498 pub formula: bool,
1499 #[xmlserde(name = b"formulaRange", ty = "attr", default = "default_false")]
1500 pub formula_range: bool,
1501 #[xmlserde(name = b"unlockedFormula", ty = "attr", default = "default_false")]
1502 pub unlocked_formula: bool,
1503 #[xmlserde(name = b"emptyCellReference", ty = "attr", default = "default_false")]
1504 pub empty_cell_reference: bool,
1505 #[xmlserde(name = b"listDataValidation", ty = "attr", default = "default_false")]
1506 pub list_data_validation: bool,
1507 #[xmlserde(name = b"calculatedColumn", ty = "attr", default = "default_false")]
1508 pub calculated_column: bool,
1509}
1510
1511#[derive(Debug, XmlSerialize, XmlDeserialize)]
1512pub struct CtIgnoredErrors {
1513 #[xmlserde(name = b"ignoredError", ty = "child")]
1514 pub ignored_errors: Vec<CtIgnoredError>,
1515}
1516
1517#[derive(Debug, XmlSerialize, XmlDeserialize)]
1518pub struct CtCellWatches {
1519 #[xmlserde(name = b"cellWatch", ty = "child")]
1520 pub cell_watches: Vec<CtCellWatch>,
1521}
1522
1523#[derive(Debug, XmlSerialize, XmlDeserialize)]
1524pub struct CtCellWatch {
1525 #[xmlserde(name = b"r", ty = "attr")]
1526 pub r: StCellRef,
1527}
1528
1529#[derive(Debug, XmlSerialize, XmlDeserialize)]
1530pub struct CtPageBreak {
1531 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
1532 pub count: u32,
1533 #[xmlserde(name = b"manualBreakCount", ty = "attr", default = "default_zero_u32")]
1534 pub manual_break_count: u32,
1535 #[xmlserde(name = b"brk", ty = "child")]
1536 pub breaks: Vec<CtBreak>,
1537}
1538
1539#[derive(Debug, XmlSerialize, XmlDeserialize)]
1540pub struct CtBreak {
1541 #[xmlserde(name = b"id", ty = "attr", default = "default_zero_u32")]
1542 pub id: u32,
1543 #[xmlserde(name = b"min", ty = "attr", default = "default_zero_u32")]
1544 pub min: u32,
1545 #[xmlserde(name = b"max", ty = "attr", default = "default_zero_u32")]
1546 pub max: u32,
1547 #[xmlserde(name = b"man", ty = "attr", default = "default_false")]
1548 pub man: bool,
1549 #[xmlserde(name = b"pt", ty = "attr", default = "default_false")]
1550 pub pt: bool,
1551}
1552
1553#[derive(Debug, XmlSerialize, XmlDeserialize)]
1554pub struct CtTableParts {
1555 #[xmlserde(name = b"tablePart", ty = "child", vec_size = "count")]
1556 pub parts: Vec<CtTablePart>,
1557 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
1558 pub count: u32,
1559}
1560
1561#[derive(Debug, XmlSerialize, XmlDeserialize)]
1562pub struct CtTablePart {
1563 #[xmlserde(name = b"r:id", ty = "attr")]
1564 pub id: String,
1565}
1566
1567#[derive(Debug, XmlSerialize, XmlDeserialize)]
1568pub struct CtSmartTags {
1569 #[xmlserde(name = b"cellSmartTags", ty = "child")]
1570 pub tags: Vec<CtCellSmartTags>,
1571}
1572
1573#[derive(Debug, XmlSerialize, XmlDeserialize)]
1574pub struct CtCellSmartTags {
1575 #[xmlserde(name = b"r", ty = "attr")]
1576 pub r: StCellRef,
1577 #[xmlserde(name = b"cellSmartTag", ty = "child")]
1578 pub tags: Vec<CtCellSmartTag>,
1579}
1580
1581#[derive(Debug, XmlSerialize, XmlDeserialize)]
1582pub struct CtCellSmartTag {
1583 #[xmlserde(name = b"cellSmartTagPr", ty = "child")]
1584 pub cell_smart_tag_pr: Vec<CtCellSmartTagPr>,
1585 #[xmlserde(name = b"type", ty = "attr")]
1586 pub ty: u32,
1587 #[xmlserde(name = b"deleted", ty = "attr", default = "default_false")]
1588 pub deleted: bool,
1589 #[xmlserde(name = b"xmlBased", ty = "attr", default = "default_false")]
1590 pub xml_based: bool,
1591}
1592
1593#[derive(Debug, XmlSerialize, XmlDeserialize)]
1594pub struct CtCellSmartTagPr {
1595 #[xmlserde(name = b"key", ty = "attr")]
1596 pub key: String,
1597 #[xmlserde(name = b"value", ty = "attr")]
1598 pub value: String,
1599}
1600
1601#[derive(Debug, XmlSerialize, XmlDeserialize)]
1602pub struct CtDrawing {
1603 #[xmlserde(name = b"r:id", ty = "attr")]
1604 pub id: String,
1605}
1606
1607#[derive(Debug, XmlSerialize, XmlDeserialize)]
1608pub struct CtDrawingHF {
1609 #[xmlserde(name = b"id", ty = "attr")]
1610 pub id: String,
1611 #[xmlserde(name = b"lho", ty = "attr")]
1612 pub lho: Option<u32>,
1613 #[xmlserde(name = b"lhe", ty = "attr")]
1614 pub lhe: Option<u32>,
1615 #[xmlserde(name = b"lhf", ty = "attr")]
1616 pub lhf: Option<u32>,
1617 #[xmlserde(name = b"cho", ty = "attr")]
1618 pub cho: Option<u32>,
1619 #[xmlserde(name = b"che", ty = "attr")]
1620 pub che: Option<u32>,
1621 #[xmlserde(name = b"chf", ty = "attr")]
1622 pub chf: Option<u32>,
1623 #[xmlserde(name = b"rho", ty = "attr")]
1624 pub rho: Option<u32>,
1625 #[xmlserde(name = b"rhe", ty = "attr")]
1626 pub rhe: Option<u32>,
1627 #[xmlserde(name = b"rhf", ty = "attr")]
1628 pub rhf: Option<u32>,
1629 #[xmlserde(name = b"lfo", ty = "attr")]
1630 pub lfo: Option<u32>,
1631 #[xmlserde(name = b"lfe", ty = "attr")]
1632 pub lfe: Option<u32>,
1633 #[xmlserde(name = b"lff", ty = "attr")]
1634 pub lff: Option<u32>,
1635 #[xmlserde(name = b"cfo", ty = "attr")]
1636 pub cfo: Option<u32>,
1637 #[xmlserde(name = b"cfe", ty = "attr")]
1638 pub cfe: Option<u32>,
1639 #[xmlserde(name = b"cff", ty = "attr")]
1640 pub cff: Option<u32>,
1641 #[xmlserde(name = b"rfo", ty = "attr")]
1642 pub rfo: Option<u32>,
1643 #[xmlserde(name = b"rfe", ty = "attr")]
1644 pub rfe: Option<u32>,
1645 #[xmlserde(name = b"rff", ty = "attr")]
1646 pub rff: Option<u32>,
1647}
1648
1649#[derive(Debug, XmlSerialize, XmlDeserialize)]
1650pub struct CtSheetProtection {
1651 #[xmlserde(name = b"algorithmName", ty = "attr")]
1652 pub algorithm_name: Option<String>,
1653 #[xmlserde(name = b"hashValue", ty = "attr")]
1654 pub hash_value: Option<String>,
1655 #[xmlserde(name = b"saltValue", ty = "attr")]
1656 pub salt_value: Option<String>,
1657 #[xmlserde(name = b"spinValue", ty = "attr")]
1658 pub spin_value: Option<String>,
1659 #[xmlserde(name = b"sheet", ty = "attr", default = "default_false")]
1660 pub sheet: bool,
1661 #[xmlserde(name = b"objects", ty = "attr", default = "default_false")]
1662 pub objects: bool,
1663 #[xmlserde(name = b"scenarios", ty = "attr", default = "default_false")]
1664 pub scenarios: bool,
1665 #[xmlserde(name = b"formatCells", ty = "attr", default = "default_true")]
1666 pub format_cells: bool,
1667 #[xmlserde(name = b"formatColumns", ty = "attr", default = "default_true")]
1668 pub format_columns: bool,
1669 #[xmlserde(name = b"formatRows", ty = "attr", default = "default_true")]
1670 pub format_rows: bool,
1671 #[xmlserde(name = b"insertColumns", ty = "attr", default = "default_true")]
1672 pub insert_columns: bool,
1673 #[xmlserde(name = b"insertRows", ty = "attr", default = "default_true")]
1674 pub insert_rows: bool,
1675 #[xmlserde(name = b"insertHyperlinks", ty = "attr", default = "default_true")]
1676 pub insert_hyperlinks: bool,
1677 #[xmlserde(name = b"deleteColumns", ty = "attr", default = "default_true")]
1678 pub delete_columns: bool,
1679 #[xmlserde(name = b"deleteRows", ty = "attr", default = "default_true")]
1680 pub delete_rows: bool,
1681 #[xmlserde(name = b"selectLockedCells", ty = "attr", default = "default_true")]
1682 pub select_locked_cells: bool,
1683 #[xmlserde(name = b"sort", ty = "attr", default = "default_true")]
1684 pub sort: bool,
1685 #[xmlserde(name = b"autoFilter", ty = "attr", default = "default_true")]
1686 pub auto_filter: bool,
1687 #[xmlserde(name = b"pivotTables", ty = "attr", default = "default_true")]
1688 pub pivot_tables: bool,
1689 #[xmlserde(name = b"selectUnlockedCells", ty = "attr", default = "default_true")]
1690 pub select_unlocked_cells: bool,
1691}
1692
1693#[derive(Debug, XmlSerialize, XmlDeserialize)]
1694pub struct CtProtectedRanges {
1695 #[xmlserde(name = b"protectedRange", ty = "child")]
1696 pub ranges: Vec<CtProtectedRange>,
1697}
1698
1699#[derive(Debug, XmlSerialize, XmlDeserialize)]
1700pub struct CtProtectedRange {
1701 #[xmlserde(name = b"securityDescriptor", ty = "child")]
1702 pub desciptors: Vec<PlainTextString>,
1703 #[xmlserde(name = b"sqref", ty = "attr")]
1704 pub sqref: String, #[xmlserde(name = b"name", ty = "attr")]
1706 pub name: String,
1707 #[xmlserde(name = b"algorithmName", ty = "attr")]
1708 pub algorithm_name: Option<String>,
1709 #[xmlserde(name = b"hashValue", ty = "attr")]
1710 pub hash_value: Option<String>,
1711 #[xmlserde(name = b"saltValue", ty = "attr")]
1712 pub salt_value: Option<String>,
1713 #[xmlserde(name = b"spinCount", ty = "attr")]
1714 pub spin_count: Option<String>,
1715}
1716
1717#[derive(Debug, XmlSerialize, XmlDeserialize)]
1718pub struct CtMergeCells {
1719 #[xmlserde(name = b"mergeCell", ty = "child", vec_size = "count")]
1720 pub merge_cells: Vec<CtMergeCell>,
1721 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
1722 pub count: u32,
1723}
1724
1725#[derive(Debug, XmlSerialize, XmlDeserialize)]
1726pub struct CtMergeCell {
1727 #[xmlserde(name = b"ref", ty = "attr")]
1728 pub reference: StRef,
1729}
1730
1731#[derive(Debug, XmlSerialize, XmlDeserialize)]
1738pub struct CtOleObject {
1739 #[xmlserde(name = b"objectPr", ty = "child")]
1740 pub object_pr: Option<CtObjectPr>,
1741 #[xmlserde(name = b"progId", ty = "attr")]
1742 pub prog_id: Option<String>,
1743 #[xmlserde(name = b"dvAspect", ty = "attr", default = "st_dv_aspect_content")]
1744 pub dv_aspect: StDvAspect,
1745 #[xmlserde(name = b"link", ty = "attr")]
1746 pub link: Option<String>,
1747 #[xmlserde(name = b"oleUpdate", ty = "attr")]
1748 pub ole_update: Option<StOleUpdate>,
1749 #[xmlserde(name = b"autoLoad", ty = "attr", default = "default_false")]
1750 pub auto_load: bool,
1751 #[xmlserde(name = b"shapeId", ty = "attr")]
1752 pub shape_id: u32,
1753 #[xmlserde(name = b"r:id", ty = "attr")]
1754 pub id: u32,
1755}
1756
1757#[derive(Debug, XmlSerialize, XmlDeserialize)]
1758pub struct CtObjectPr {
1759 #[xmlserde(name = b"anchor", ty = "child")]
1760 pub anchor: CtObjectAnchor,
1761 #[xmlserde(name = b"locked", ty = "attr", default = "default_true")]
1762 pub locked: bool,
1763 #[xmlserde(name = b"defaultSize", ty = "attr", default = "default_true")]
1764 pub default_size: bool,
1765 #[xmlserde(name = b"print", ty = "attr", default = "default_true")]
1766 pub print: bool,
1767 #[xmlserde(name = b"disabled", ty = "attr", default = "default_false")]
1768 pub disabled: bool,
1769 #[xmlserde(name = b"ui_object", ty = "attr", default = "default_false")]
1770 pub ui_object: bool,
1771 #[xmlserde(name = b"autoFill", ty = "attr", default = "default_true")]
1772 pub auto_fill: bool,
1773 #[xmlserde(name = b"autoLine", ty = "attr", default = "default_true")]
1774 pub auto_line: bool,
1775 #[xmlserde(name = b"autoPict", ty = "attr", default = "default_true")]
1776 pub auto_pict: bool,
1777 #[xmlserde(name = b"macro", ty = "attr")]
1778 pub macr: Option<StFormula>,
1779 #[xmlserde(name = b"altText", ty = "attr")]
1780 pub alt_text: Option<String>,
1781 #[xmlserde(name = b"dde", ty = "attr", default = "default_false")]
1782 pub dde: bool,
1783 #[xmlserde(name = b"r:id", ty = "attr")]
1784 pub id: Option<String>,
1785}
1786
1787#[derive(Debug, XmlSerialize, XmlDeserialize)]
1788pub struct CtPrintOptions {
1789 #[xmlserde(name = b"horizontalCentered", ty = "attr", default = "default_false")]
1790 pub horizontal_centered: bool,
1791 #[xmlserde(name = b"verticalCentered", ty = "attr", default = "default_false")]
1792 pub vertical_centered: bool,
1793 #[xmlserde(name = b"headings", ty = "attr", default = "default_false")]
1794 pub headings: bool,
1795 #[xmlserde(name = b"gridLines", ty = "attr", default = "default_false")]
1796 pub grid_lines: bool,
1797 #[xmlserde(name = b"gridLinesSet", ty = "attr", default = "default_true")]
1798 pub grid_lines_set: bool,
1799}
1800
1801#[derive(Debug, XmlSerialize, XmlDeserialize)]
1802pub struct CtPageSetup {
1803 #[xmlserde(name = b"paperSize", ty = "attr", default = "default_one_u32")]
1804 pub paper_size: u32,
1805 #[xmlserde(name = b"paperHeight", ty = "attr")]
1806 pub paper_height: Option<StPositiveUniversalMeasure>,
1807 #[xmlserde(name = b"paperWidth", ty = "attr")]
1808 pub paper_width: Option<StPositiveUniversalMeasure>,
1809 #[xmlserde(name = b"scale", ty = "attr", default = "default_100_u32")]
1810 pub scale: u32,
1811 #[xmlserde(name = b"firstPageNumber", ty = "attr", default = "default_one_u32")]
1812 pub first_page_number: u32,
1813 #[xmlserde(name = b"fitToWidth", ty = "attr", default = "default_one_u32")]
1814 pub fit_to_width: u32,
1815 #[xmlserde(name = b"fitToHeight", ty = "attr", default = "default_one_u32")]
1816 pub fit_to_height: u32,
1817 #[xmlserde(
1818 name = b"pageOrder",
1819 ty = "attr",
1820 default = "st_page_order_down_then_over"
1821 )]
1822 pub page_order: StPageOrder,
1823 #[xmlserde(name = b"orientation", ty = "attr", default = "st_orientation_default")]
1824 pub orientation: StOrientation,
1825 #[xmlserde(name = b"usePrinterDefaults", ty = "attr", default = "default_true")]
1826 pub use_printer_defaults: bool,
1827 #[xmlserde(name = b"blackAndWhite", ty = "attr", default = "default_false")]
1828 pub black_and_white: bool,
1829 #[xmlserde(name = b"draft", ty = "attr", default = "default_false")]
1830 pub draft: bool,
1831 #[xmlserde(name = b"cellComments", ty = "attr", default = "st_cell_comments_none")]
1832 pub cell_comments: StCellComments,
1833 #[xmlserde(name = b"useFirstPageNumber", ty = "attr", default = "default_false")]
1834 pub use_first_page_number: bool,
1835 #[xmlserde(name = b"errors", ty = "attr", default = "st_print_error_displayed")]
1836 pub errors: StPrintError,
1837 #[xmlserde(name = b"horizontalDpi", ty = "attr", default = "default_600_u32")]
1838 pub horizontal_dpi: u32,
1839 #[xmlserde(name = b"verticalDpi", ty = "attr", default = "default_600_u32")]
1840 pub vertical_dpi: u32,
1841 #[xmlserde(name = b"copies", ty = "attr", default = "default_one_u32")]
1842 pub copies: u32,
1843 #[xmlserde(name = b"r:id", ty = "attr")]
1844 pub id: Option<String>,
1845}
1846
1847#[derive(Debug, XmlSerialize, XmlDeserialize)]
1848pub struct CtWebPublishItems {
1849 #[xmlserde(name = b"webPublishItem", ty = "child", vec_size = "count")]
1850 pub items: Vec<CtWebPublishItem>,
1851 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
1852 pub count: u32,
1853}
1854
1855#[derive(Debug, XmlSerialize, XmlDeserialize)]
1856pub struct CtWebPublishItem {
1857 #[xmlserde(name = b"id", ty = "attr")]
1858 pub id: u32,
1859 #[xmlserde(name = b"divId", ty = "attr")]
1860 pub div_id: String,
1861 #[xmlserde(name = b"sourceType", ty = "attr")]
1862 pub source_type: StWebSourceType,
1863 #[xmlserde(name = b"sourceRef", ty = "attr")]
1864 pub source_ref: Option<StRef>,
1865 #[xmlserde(name = b"sourceObject", ty = "attr")]
1866 pub source_object: Option<String>,
1867 #[xmlserde(name = b"destinationFile", ty = "attr")]
1868 pub destination_file: String,
1869 #[xmlserde(name = b"title", ty = "attr")]
1870 pub title: Option<String>,
1871 #[xmlserde(name = b"autoRepublish", ty = "attr", default = "default_true")]
1872 pub auto_republish: bool,
1873}
1874
1875#[derive(Debug, XmlSerialize, XmlDeserialize)]
1876pub struct CtSortState {
1877 #[xmlserde(name = b"sortCondition", ty = "child")]
1878 pub condictions: Vec<CtSortCondition>,
1879 #[xmlserde(name = b"columnSort", ty = "attr", default = "default_false")]
1880 pub column_sort: bool,
1881 #[xmlserde(name = b"caseSentitive", ty = "attr", default = "default_false")]
1882 pub case_sensitive: bool,
1883}
1884
1885#[derive(Debug, XmlSerialize, XmlDeserialize)]
1886pub struct CtSortCondition {
1887 #[xmlserde(name = b"descending", ty = "attr", default = "default_false")]
1888 pub descending: bool,
1889 #[xmlserde(name = b"sortBy", ty = "attr", default = "st_sort_by_value")]
1890 pub sort_by: StSortBy,
1891 #[xmlserde(name = b"ref", ty = "attr")]
1892 pub reference: StRef,
1893 #[xmlserde(name = b"customList", ty = "attr")]
1894 pub custom_list: Option<String>,
1895 #[xmlserde(name = b"dxfId", ty = "attr")]
1896 pub dxf_id: Option<StDxfId>,
1897 #[xmlserde(name = b"iconSet", ty = "attr", default = "st_icon_set_type_3arrows")]
1898 pub icon_set: StIconSetType,
1899 #[xmlserde(name = b"iconId", ty = "attr")]
1900 pub icon_id: Option<u32>,
1901}
1902
1903#[derive(Debug, XmlSerialize, XmlDeserialize)]
1904pub struct CtPageMargins {
1905 #[xmlserde(name = b"left", ty = "attr")]
1906 pub left: f64,
1907 #[xmlserde(name = b"right", ty = "attr")]
1908 pub right: f64,
1909 #[xmlserde(name = b"top", ty = "attr")]
1910 pub top: f64,
1911 #[xmlserde(name = b"bottom", ty = "attr")]
1912 pub bottom: f64,
1913 #[xmlserde(name = b"header", ty = "attr")]
1914 pub header: f64,
1915 #[xmlserde(name = b"footer", ty = "attr")]
1916 pub footer: f64,
1917}
1918
1919#[derive(Debug, XmlSerialize, XmlDeserialize)]
1920pub struct CtAutoFilter {
1921 #[xmlserde(name = b"filterColumn", ty = "child")]
1922 pub filter_columns: Vec<CtFilterColumn>,
1923 #[xmlserde(name = b"sortState", ty = "child")]
1924 pub sort_state: Option<CtSortState>,
1925 #[xmlserde(name = b"ref", ty = "attr")]
1926 pub reference: StRef,
1927}
1928
1929#[derive(Debug, XmlSerialize, XmlDeserialize)]
1930pub struct CtFilterColumn {
1931 #[xmlserde(name = b"filters", ty = "child")]
1933 pub filters: Option<CtFilters>,
1934 #[xmlserde(name = b"top10", ty = "child")]
1935 pub top10: Option<CtTop10>,
1936 #[xmlserde(name = b"customFilters", ty = "child")]
1937 pub custom_filters: Option<CtCustomFilters>,
1938 #[xmlserde(name = b"dynamicFilter", ty = "child")]
1939 pub dynamic_filter: Option<CtDynamicFilter>,
1940 #[xmlserde(name = b"colorFilter", ty = "child")]
1941 pub color_filter: Option<CtColorFilter>,
1942 #[xmlserde(name = b"iconFilter", ty = "child")]
1943 pub icon_filter: Option<CtIconFilter>,
1944 #[xmlserde(name = b"colId", ty = "attr")]
1946 pub col_id: u32,
1947 #[xmlserde(name = b"hiddenButton", ty = "attr", default = "default_false")]
1948 pub hidden_button: bool,
1949 #[xmlserde(name = b"showButton", ty = "attr", default = "default_true")]
1950 pub show_button: bool,
1951}
1952
1953#[derive(Debug, XmlSerialize, XmlDeserialize)]
1954pub struct CtFilters {
1955 #[xmlserde(name = b"filter", ty = "child")]
1956 pub filters: Vec<CtFilter>,
1957 #[xmlserde(name = b"dateGroupItem", ty = "child")]
1958 pub date_group_item: Vec<CtDateGroupItem>,
1959 #[xmlserde(name = b"blank", ty = "attr", default = "default_false")]
1960 pub blank: bool,
1961 #[xmlserde(name = b"calendarType", ty = "attr", default = "st_calendar_type_none")]
1962 pub calendar_type: StCalendarType,
1963}
1964
1965#[derive(Debug, XmlSerialize, XmlDeserialize)]
1966pub struct CtDateGroupItem {
1967 #[xmlserde(name = b"year", ty = "attr")]
1968 pub year: u16,
1969 #[xmlserde(name = b"month", ty = "attr")]
1970 pub month: u8,
1971 #[xmlserde(name = b"day", ty = "attr")]
1972 pub day: u8,
1973 #[xmlserde(name = b"hour", ty = "attr")]
1974 pub hour: u8,
1975 #[xmlserde(name = b"minute", ty = "attr")]
1976 pub minute: u8,
1977 #[xmlserde(name = b"second", ty = "attr")]
1978 pub second: u8,
1979 #[xmlserde(name = b"dateTimeGrouping", ty = "attr")]
1980 pub date_time_grouping: StDateTimeGrouping,
1981}
1982
1983#[derive(Debug, XmlSerialize, XmlDeserialize)]
1984pub struct CtFilter {
1985 #[xmlserde(name = b"val", ty = "attr")]
1986 pub val: String,
1987}
1988
1989#[derive(Debug, XmlSerialize, XmlDeserialize)]
1990pub struct CtCustomFilters {
1991 #[xmlserde(name = b"customFilter", ty = "child")]
1992 pub filters: Vec<CtCustomFilter>,
1993 #[xmlserde(name = b"and", ty = "attr", default = "default_false")]
1994 pub and: bool,
1995}
1996
1997#[derive(Debug, XmlSerialize, XmlDeserialize)]
1998pub struct CtCustomFilter {
1999 #[xmlserde(name = b"operator", ty = "attr", default = "st_filter_operator_equal")]
2000 pub operator: StFilterOperator,
2001 #[xmlserde(name = b"val", ty = "attr")]
2002 pub val: String,
2003}
2004
2005#[derive(Debug, XmlSerialize, XmlDeserialize)]
2006pub struct CtTop10 {
2007 #[xmlserde(name = b"top", ty = "attr", default = "default_true")]
2008 pub top: bool,
2009 #[xmlserde(name = b"percent", ty = "attr", default = "default_false")]
2010 pub percent: bool,
2011 #[xmlserde(name = b"val", ty = "attr")]
2012 pub val: f64,
2013 #[xmlserde(name = b"filterVal", ty = "attr")]
2014 pub filter_val: Option<f64>,
2015}
2016
2017#[derive(Debug, XmlSerialize, XmlDeserialize)]
2018pub struct CtColorFilter {
2019 #[xmlserde(name = b"dxfId", ty = "attr")]
2020 pub dxf_id: Option<StDxfId>,
2021 #[xmlserde(name = b"cellColor", ty = "attr", default = "default_true")]
2022 pub cell_color: bool,
2023}
2024
2025#[derive(Debug, XmlSerialize, XmlDeserialize)]
2026pub struct CtIconFilter {
2027 #[xmlserde(name = b"iconSet", ty = "attr")]
2028 pub icon_set: StIconSetType,
2029 #[xmlserde(name = b"iconId", ty = "attr")]
2030 pub icon_id: Option<u32>,
2031}
2032
2033#[derive(Debug, XmlSerialize, XmlDeserialize)]
2034pub struct CtDynamicFilter {
2035 #[xmlserde(name = b"type", ty = "attr")]
2036 pub ty: StDynamicFilterType,
2037 #[xmlserde(name = b"val", ty = "attr")]
2038 pub val: Option<f64>,
2039 #[xmlserde(name = b"valIso", ty = "attr")]
2040 pub val_iso: Option<String>,
2041 #[xmlserde(name = b"maxValIso", ty = "attr")]
2042 pub max_val_iso: Option<String>,
2043}
2044
2045#[derive(Debug, XmlSerialize, XmlDeserialize)]
2046pub struct CtHyperlinks {
2047 #[xmlserde(name = b"hyperlink", ty = "child")]
2048 pub links: Vec<CtHyperlink>,
2049}
2050
2051#[derive(Debug, XmlSerialize, XmlDeserialize)]
2052pub struct CtHyperlink {
2053 #[xmlserde(name = b"ref", ty = "attr")]
2054 pub reference: StRef,
2055 #[xmlserde(name = b"r:id", ty = "attr")]
2056 pub id: Option<String>,
2057 #[xmlserde(name = b"location", ty = "attr")]
2058 pub location: Option<String>,
2059 #[xmlserde(name = b"tooltip", ty = "attr")]
2060 pub tooltip: Option<String>,
2061 #[xmlserde(name = b"display", ty = "attr")]
2062 pub display: Option<String>,
2063}
2064
2065#[derive(Debug, XmlSerialize, XmlDeserialize)]
2066pub struct CtDataConsolidate {
2067 #[xmlserde(name = b"dataRefs", ty = "child")]
2068 pub data_refs: Option<CtDataRefs>,
2069 #[xmlserde(
2070 name = b"function",
2071 ty = "attr",
2072 default = "st_data_consolidate_function_sum"
2073 )]
2074 pub function: StDataConsolidateFunction,
2075 #[xmlserde(name = b"startLabels", ty = "attr", default = "default_false")]
2076 pub start_labels: bool,
2077 #[xmlserde(name = b"topLabels", ty = "attr", default = "default_false")]
2078 pub top_labels: bool,
2079 #[xmlserde(name = b"link", ty = "attr", default = "default_false")]
2080 pub link: bool,
2081}
2082
2083#[derive(Debug, XmlSerialize, XmlDeserialize)]
2084pub struct CtDataRefs {
2085 #[xmlserde(name = b"dataRef", ty = "child", vec_size = "count")]
2086 pub data_ref: Vec<CtDataRef>,
2087 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
2088 pub count: u32,
2089}
2090
2091#[derive(Debug, XmlSerialize, XmlDeserialize)]
2092pub struct CtDataRef {
2093 #[xmlserde(name = b"ref", ty = "attr")]
2094 pub reference: Option<StRef>,
2095 #[xmlserde(name = b"name", ty = "attr")]
2096 pub name: Option<String>,
2097 #[xmlserde(name = b"sheet", ty = "attr")]
2098 pub sheet: Option<String>,
2099}
2100
2101#[derive(Debug, XmlSerialize, XmlDeserialize)]
2102pub struct CtScenarios {
2103 #[xmlserde(name = b"scenario", ty = "child")]
2104 pub scearios: Vec<CtScenario>,
2105 #[xmlserde(name = b"current", ty = "attr")]
2106 pub current: Option<u32>,
2107 #[xmlserde(name = b"show", ty = "attr")]
2108 pub show: Option<u32>,
2109 #[xmlserde(name = b"sqref", ty = "attr")]
2110 pub sqref: Option<String>,
2111}
2112
2113#[derive(Debug, XmlSerialize, XmlDeserialize)]
2114pub struct CtScenario {
2115 #[xmlserde(name = b"CtInputCells", ty = "child")]
2116 pub input_cells: Vec<CtInputCells>,
2117 #[xmlserde(name = b"name", ty = "attr")]
2118 pub name: String,
2119 #[xmlserde(name = b"locked", ty = "attr", default = "default_false")]
2120 pub locked: bool,
2121 #[xmlserde(name = b"hidden", ty = "attr", default = "default_false")]
2122 pub hidden: bool,
2123 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
2124 pub count: u32,
2125 #[xmlserde(name = b"user", ty = "attr")]
2126 pub user: Option<String>,
2127 #[xmlserde(name = b"comment", ty = "attr")]
2128 pub comment: Option<String>,
2129}
2130
2131#[derive(Debug, XmlSerialize, XmlDeserialize)]
2132pub struct CtInputCells {
2133 #[xmlserde(name = b"r", ty = "attr")]
2134 pub r: StCellRef,
2135 #[xmlserde(name = b"deleted", ty = "attr", default = "default_false")]
2136 pub deleted: bool,
2137 #[xmlserde(name = b"undone", ty = "attr", default = "default_false")]
2138 pub undone: bool,
2139 #[xmlserde(name = b"val", ty = "attr")]
2140 pub val: String,
2141 #[xmlserde(name = b"numFmtId", ty = "attr")]
2142 pub num_fmt_id: Option<StNumFmtId>,
2143}
2144
2145#[derive(Debug, XmlSerialize, XmlDeserialize)]
2146pub struct CtHeaderFooter {
2147 #[xmlserde(name = b"oddHeader", ty = "child")]
2148 pub odd_header: Option<PlainTextString>,
2149 #[xmlserde(name = b"oddFooter", ty = "child")]
2150 pub odd_footer: Option<PlainTextString>,
2151 #[xmlserde(name = b"evenHeader", ty = "child")]
2152 pub even_header: Option<PlainTextString>,
2153 #[xmlserde(name = b"evenFooter", ty = "child")]
2154 pub even_footer: Option<PlainTextString>,
2155 #[xmlserde(name = b"firstHeader", ty = "child")]
2156 pub first_header: Option<PlainTextString>,
2157 #[xmlserde(name = b"firstFooter", ty = "child")]
2158 pub first_footer: Option<PlainTextString>,
2159 #[xmlserde(name = b"differentOddEven", ty = "attr", default = "default_false")]
2160 pub different_odd_even: bool,
2161 #[xmlserde(name = b"differentFirst", ty = "attr", default = "default_false")]
2162 pub different_first: bool,
2163 #[xmlserde(name = b"scaleWithDoc", ty = "attr", default = "default_true")]
2164 pub scale_with_doc: bool,
2165 #[xmlserde(name = b"alignWithMargins", ty = "attr", default = "default_true")]
2166 pub align_with_margins: bool,
2167}
2168
2169#[derive(Debug, XmlSerialize, XmlDeserialize)]
2170pub struct CtDataValidations {
2171 #[xmlserde(name = b"dataValidation", ty = "child", vec_size = "count")]
2172 pub data_validations: Vec<CtDataValidation>,
2173 #[xmlserde(name = b"disablePrompts", ty = "attr", default = "default_false")]
2174 pub disable_prompts: bool,
2175 #[xmlserde(name = b"xWindow", ty = "attr")]
2176 pub x_window: Option<u32>,
2177 #[xmlserde(name = b"yWindow", ty = "attr")]
2178 pub y_window: Option<u32>,
2179 #[xmlserde(name = b"count", ty = "attr", default = "default_zero_u32")]
2180 pub count: u32,
2181}
2182
2183#[derive(Debug, XmlSerialize, XmlDeserialize)]
2184pub struct CtDataValidation {
2185 #[xmlserde(name = b"formula1", ty = "child")]
2186 pub formula1: Option<PlainTextString>,
2187 #[xmlserde(name = b"formula2", ty = "child")]
2188 pub formula2: Option<PlainTextString>,
2189 #[xmlserde(name = b"type", ty = "attr", default = "st_data_validation_type_none")]
2190 pub ty: StDataValidationType,
2191 #[xmlserde(
2192 name = b"errorStyle",
2193 ty = "attr",
2194 default = "st_data_validation_error_style_stop"
2195 )]
2196 pub error_style: StDataValidationErrorStyle,
2197 #[xmlserde(
2198 name = b"imeMode",
2199 ty = "attr",
2200 default = "st_data_validation_ime_mode_no_control"
2201 )]
2202 pub ime_mode: StDataValidationImeMode,
2203 #[xmlserde(
2204 name = b"operator",
2205 ty = "attr",
2206 default = "st_data_validation_operator_between"
2207 )]
2208 pub operator: StDataValidationOperator,
2209 #[xmlserde(name = b"blank", ty = "attr", default = "default_false")]
2210 pub blank: bool,
2211 #[xmlserde(name = b"showDropDown", ty = "attr", default = "default_false")]
2212 pub show_drop_down: bool,
2213 #[xmlserde(name = b"showInputMessage", ty = "attr", default = "default_false")]
2214 pub show_input_message: bool,
2215 #[xmlserde(name = b"showErrorMessage", ty = "attr", default = "default_false")]
2216 pub show_error_message: bool,
2217 #[xmlserde(name = b"promptTitle", ty = "attr")]
2218 pub prompt_title: Option<String>,
2219 #[xmlserde(name = b"prompt", ty = "attr")]
2220 pub prompt: Option<String>,
2221 #[xmlserde(name = b"sqref", ty = "attr")]
2222 pub sqref: String,
2223}
2224
2225#[derive(Debug, XmlSerialize, XmlDeserialize)]
2226pub struct CtConditionalFormatting {
2227 #[xmlserde(name = b"cfRule", ty = "child")]
2228 pub cf_rules: Vec<CtCfRule>,
2229 #[xmlserde(name = b"pivot", ty = "attr", default = "default_false")]
2230 pub pviot: bool,
2231 #[xmlserde(name = b"sqref", ty = "attr")]
2232 pub sqref: String,
2233}
2234
2235#[derive(Debug, XmlSerialize, XmlDeserialize)]
2236pub struct CtCfRule {
2237 #[xmlserde(name = b"formula", ty = "child")]
2238 pub formulas: Vec<PlainTextString>,
2239 #[xmlserde(name = b"colorScale", ty = "child")]
2240 pub color_scale: Option<CtColorScale>,
2241 #[xmlserde(name = b"dataBar", ty = "child")]
2242 pub data_bar: Option<CtDataBar>,
2243 #[xmlserde(name = b"iconSet", ty = "child")]
2244 pub icon_set: Option<CtIconSet>,
2245 #[xmlserde(name = b"type", ty = "attr")]
2246 pub ty: StCfType,
2247 #[xmlserde(name = b"dxfId", ty = "attr")]
2248 pub dxf_id: Option<StDxfId>,
2249 #[xmlserde(name = b"priority", ty = "attr")]
2250 pub priority: i32,
2251 #[xmlserde(name = b"stopIfTrue", ty = "attr", default = "default_false")]
2252 pub stop_if_true: bool,
2253 #[xmlserde(name = b"aboveAverage", ty = "attr", default = "default_true")]
2254 pub above_average: bool,
2255 #[xmlserde(name = b"percent", ty = "attr", default = "default_false")]
2256 pub percent: bool,
2257 #[xmlserde(name = b"bottom", ty = "attr", default = "default_false")]
2258 pub bottom: bool,
2259 #[xmlserde(name = b"operator", ty = "attr")]
2260 pub operator: Option<StConditionalFormattingOperator>,
2261 #[xmlserde(name = b"text", ty = "attr")]
2262 pub text: Option<String>,
2263 #[xmlserde(name = b"timePeriod", ty = "attr")]
2264 pub time_period: Option<StTimePeriod>,
2265 #[xmlserde(name = b"rank", ty = "attr")]
2266 pub rank: Option<u32>,
2267 #[xmlserde(name = b"stdDev", ty = "attr")]
2268 pub std_dev: Option<i32>,
2269 #[xmlserde(name = b"equalAverage", ty = "attr", default = "default_false")]
2270 pub equal_average: bool,
2271}
2272
2273#[derive(Debug, XmlSerialize, XmlDeserialize)]
2274pub struct CtDataBar {
2275 #[xmlserde(name = b"cfvo", ty = "child")]
2276 pub cfvos: Vec<CtCfvo>, #[xmlserde(name = b"color", ty = "child")]
2278 pub color: CtColor,
2279 #[xmlserde(name = b"minLength", ty = "attr", default = "default_10_u32")]
2280 pub min_length: u32,
2281 #[xmlserde(name = b"maxLength", ty = "attr", default = "default_90_u32")]
2282 pub max_length: u32,
2283 #[xmlserde(name = b"showValue", ty = "attr", default = "default_true")]
2284 pub show_value: bool,
2285}
2286
2287#[derive(Debug, XmlSerialize, XmlDeserialize)]
2288pub struct CtIconSet {
2289 #[xmlserde(name = b"cfvo", ty = "child")]
2290 pub cfvos: Vec<CtCfvo>, #[xmlserde(
2292 name = b"iconSet",
2293 ty = "attr",
2294 default = "st_icon_set_type_3_traffic_lights1"
2295 )]
2296 pub icon_set: StIconSetType,
2297 #[xmlserde(name = b"showValue", ty = "attr", default = "default_true")]
2298 pub show_value: bool,
2299 #[xmlserde(name = b"percent", ty = "attr", default = "default_true")]
2300 pub percent: bool,
2301 #[xmlserde(name = b"reverse", ty = "attr", default = "default_false")]
2302 pub reverse: bool,
2303}
2304
2305#[derive(Debug, XmlSerialize, XmlDeserialize)]
2306pub struct CtCfvo {
2307 #[xmlserde(name = b"type", ty = "attr")]
2308 pub ty: StCfvoType,
2309 #[xmlserde(name = b"val", ty = "attr")]
2310 pub val: Option<String>,
2311 #[xmlserde(name = b"gte", ty = "attr", default = "default_true")]
2312 pub gte: bool,
2313}
2314
2315#[derive(Debug, XmlSerialize, XmlDeserialize)]
2316pub struct CtColorScale {
2317 #[xmlserde(name = b"cfvo", ty = "child")]
2318 pub cfvos: Vec<CtCfvo>, #[xmlserde(name = b"color", ty = "child")]
2320 pub colors: Vec<CtColor>, }
2322
2323#[derive(Debug, XmlSerialize, XmlDeserialize)]
2324pub struct CtCustomProperties {
2325 #[xmlserde(name = b"customPr", ty = "child")]
2326 pub custom_prs: Vec<CtCustomProperty>,
2327}
2328
2329#[derive(Debug, XmlSerialize, XmlDeserialize)]
2330pub struct CtCustomProperty {
2331 #[xmlserde(name = b"name", ty = "attr")]
2332 pub name: String,
2333 #[xmlserde(name = b"r:id", ty = "attr")]
2334 pub id: String,
2335}
2336
2337#[derive(Debug, XmlSerialize, XmlDeserialize)]
2338pub struct CtCustomSheetViews {
2339 #[xmlserde(name = b"custom_sheet_view", ty = "child")]
2340 pub views: Vec<CtCustomSheetView>,
2341}
2342
2343#[derive(Debug, XmlSerialize, XmlDeserialize)]
2344pub struct CtCustomSheetView {
2345 #[xmlserde(name = b"pane", ty = "child")]
2346 pub pane: Option<CtPane>,
2347 #[xmlserde(name = b"selection", ty = "child")]
2348 pub selection: Option<CtSelection>,
2349 #[xmlserde(name = b"rowBreaks", ty = "child")]
2350 pub row_breaks: Option<CtPageBreak>,
2351 #[xmlserde(name = b"colBreaks", ty = "child")]
2352 pub col_breaks: Option<CtPageBreak>,
2353 #[xmlserde(name = b"pageMargins", ty = "child")]
2354 pub page_margins: Option<CtPageMargins>,
2355 #[xmlserde(name = b"printOptions", ty = "child")]
2356 pub print_options: Option<CtPrintOptions>,
2357 #[xmlserde(name = b"pageSetup", ty = "child")]
2358 pub page_setup: Option<CtPageSetup>,
2359 #[xmlserde(name = b"headerFooter", ty = "child")]
2360 pub header_footer: Option<CtHeaderFooter>,
2361 #[xmlserde(name = b"autoFilter", ty = "child")]
2362 pub auto_filter: Option<CtAutoFilter>,
2363 #[xmlserde(name = b"guid", ty = "attr")]
2364 pub guid: String,
2365 #[xmlserde(name = b"scale", ty = "attr", default = "default_100_u32")]
2366 pub scale: u32,
2367 #[xmlserde(name = b"colorId", ty = "attr", default = "default_color_id")]
2368 pub color_id: u32,
2369 #[xmlserde(name = b"showPageBreaks", ty = "attr", default = "default_false")]
2370 pub show_page_breaks: bool,
2371 #[xmlserde(name = b"showFormulas", ty = "attr", default = "default_false")]
2372 pub show_formulas: bool,
2373 #[xmlserde(name = b"showGridLines", ty = "attr", default = "default_true")]
2374 pub show_grid_lines: bool,
2375 #[xmlserde(name = b"showRowCol", ty = "attr", default = "default_true")]
2376 pub show_row_col: bool,
2377 #[xmlserde(name = b"outlineSymbols", ty = "attr", default = "default_true")]
2378 pub outline_symbols: bool,
2379 #[xmlserde(name = b"", ty = "attr", default = "default_true")]
2380 pub zero_values: bool,
2381 #[xmlserde(name = b"fitToPage", ty = "attr", default = "default_false")]
2382 pub fit_to_page: bool,
2383 #[xmlserde(name = b"printArea", ty = "attr", default = "default_false")]
2384 pub print_area: bool,
2385 #[xmlserde(name = b"filter", ty = "attr", default = "default_false")]
2386 pub filter: bool,
2387 #[xmlserde(name = b"showAutoFilter", ty = "attr", default = "default_false")]
2388 pub show_auto_filter: bool,
2389 #[xmlserde(name = b"hiddenRows", ty = "attr", default = "default_false")]
2390 pub hidden_rows: bool,
2391 #[xmlserde(name = b"hiddenColumns", ty = "attr", default = "default_false")]
2392 pub hidden_columns: bool,
2393 #[xmlserde(name = b"state", ty = "attr", default = "st_sheet_state_visible")]
2394 pub state: StSheetState,
2395 #[xmlserde(name = b"filterUnique", ty = "attr", default = "default_false")]
2396 pub filter_unique: bool,
2397 #[xmlserde(name = b"view", ty = "attr", default = "st_sheet_view_type_normal")]
2398 pub view: StSheetViewType,
2399 #[xmlserde(name = b"showRuler", ty = "attr", default = "default_true")]
2400 pub show_ruler: bool,
2401 #[xmlserde(name = b"topLeftCell", ty = "attr")]
2402 pub top_left_cell: Option<StCellRef>,
2403}
2404
2405#[derive(Debug, XmlSerialize, XmlDeserialize)]
2406pub struct CtSheetBackgroundPicture {
2407 #[xmlserde(name = b"r:id", ty = "attr")]
2408 pub id: String,
2409}
2410
2411#[derive(Debug, XmlSerialize, XmlDeserialize)]
2412pub struct CtSheetData {
2413 #[xmlserde(name = b"row", ty = "child")]
2414 pub rows: Vec<CtRow>,
2415}
2416
2417#[derive(Debug, XmlSerialize, XmlDeserialize)]
2418pub struct CtRow {
2419 #[xmlserde(name = b"c", ty = "child")]
2420 pub cells: Vec<CtCell>,
2421 #[xmlserde(name = b"r", ty = "attr")]
2422 pub r: Option<u32>,
2423 #[xmlserde(name = b"spans", ty = "attr")]
2424 pub spans: Option<String>, #[xmlserde(name = b"s", ty = "attr", default = "default_zero_u32")]
2426 pub s: u32,
2427 #[xmlserde(name = b"customFormat", ty = "attr", default = "default_false")]
2428 pub custom_format: bool,
2429 #[xmlserde(name = b"ht", ty = "attr")]
2430 pub ht: Option<f64>,
2431 #[xmlserde(name = b"hidden", ty = "attr", default = "default_false")]
2432 pub hidden: bool,
2433 #[xmlserde(name = b"customHeight", ty = "attr", default = "default_false")]
2434 pub custom_height: bool,
2435 #[xmlserde(name = b"outlineLevel", ty = "attr", default = "default_zero_u8")]
2436 pub outline_level: u8,
2437 #[xmlserde(name = b"collapsed", ty = "attr", default = "default_false")]
2438 pub collapsed: bool,
2439 #[xmlserde(name = b"thickTop", ty = "attr", default = "default_false")]
2440 pub thick_top: bool,
2441 #[xmlserde(name = b"thickBot", ty = "attr", default = "default_false")]
2442 pub thick_bot: bool,
2443 #[xmlserde(name = b"ph", ty = "attr", default = "default_false")]
2444 pub ph: bool,
2445}
2446
2447#[derive(Debug, XmlSerialize, XmlDeserialize)]
2448pub struct CtCell {
2449 #[xmlserde(name = b"f", ty = "child")]
2450 pub f: Option<CtFormula>,
2451 #[xmlserde(name = b"v", ty = "child")]
2452 pub v: Option<PlainTextString>,
2453 #[xmlserde(name = b"is", ty = "child")]
2454 pub is: Option<CtRst>,
2455 #[xmlserde(name = b"r", ty = "attr")]
2456 pub r: Option<StCellRef>,
2457 #[xmlserde(name = b"s", ty = "attr", default = "default_zero_u32")]
2458 pub s: u32,
2459 #[xmlserde(name = b"t", ty = "attr", default = "st_cell_type_n")]
2460 pub t: StCellType,
2461 #[xmlserde(name = b"cm", ty = "attr", default = "default_zero_u32")]
2462 pub cm: u32,
2463 #[xmlserde(name = b"vm", ty = "attr", default = "default_zero_u32")]
2464 pub vm: u32,
2465 #[xmlserde(name = b"ph", ty = "attr", default = "default_false")]
2466 pub ph: bool,
2467}
2468
2469mod tests {
2470 use super::*;
2471
2472 #[derive(Debug, XmlSerialize, XmlDeserialize)]
2473 pub struct CtFormula {
2474 #[xmlserde(ty = "text")]
2475 pub formula: Option<String>,
2476 #[xmlserde(name = b"t", ty = "attr", default = "st_cell_formula_type_normal")]
2477 pub t: StCellFormulaType,
2478 #[xmlserde(name = b"aca", ty = "attr", default = "default_false")]
2479 pub aca: bool,
2480 #[xmlserde(name = b"ref", ty = "attr")]
2481 pub reference: Option<StRef>,
2482 #[xmlserde(name = b"dt2D", ty = "attr", default = "default_false")]
2483 pub dt_2d: bool,
2484 #[xmlserde(name = b"del1", ty = "attr", default = "default_false")]
2485 pub del1: bool,
2486 #[xmlserde(name = b"del2", ty = "attr", default = "default_false")]
2487 pub del2: bool,
2488 #[xmlserde(name = b"r1", ty = "attr")]
2489 pub r1: Option<StCellRef>,
2490 #[xmlserde(name = b"r2", ty = "attr")]
2491 pub r2: Option<StCellRef>,
2492 #[xmlserde(name = b"ca", ty = "attr", default = "default_false")]
2493 pub ca: bool,
2494 #[xmlserde(name = b"si", ty = "attr")]
2495 pub si: Option<u32>,
2496 #[xmlserde(name = b"bx", ty = "attr", default = "default_false")]
2497 pub bx: bool,
2498 }
2499}
2500#[derive(Debug, XmlSerialize, XmlDeserialize)]
2501pub struct CtFormula {
2502 #[xmlserde(ty = "text")]
2503 pub formula: Option<String>,
2504 #[xmlserde(name = b"t", ty = "attr", default = "st_cell_formula_type_normal")]
2505 pub t: StCellFormulaType,
2506 #[xmlserde(name = b"aca", ty = "attr", default = "default_false")]
2507 pub aca: bool,
2508 #[xmlserde(name = b"ref", ty = "attr")]
2509 pub reference: Option<StRef>,
2510 #[xmlserde(name = b"dt2D", ty = "attr", default = "default_false")]
2511 pub dt_2d: bool,
2512 #[xmlserde(name = b"del1", ty = "attr", default = "default_false")]
2513 pub del1: bool,
2514 #[xmlserde(name = b"del2", ty = "attr", default = "default_false")]
2515 pub del2: bool,
2516 #[xmlserde(name = b"r1", ty = "attr")]
2517 pub r1: Option<StCellRef>,
2518 #[xmlserde(name = b"r2", ty = "attr")]
2519 pub r2: Option<StCellRef>,
2520 #[xmlserde(name = b"ca", ty = "attr", default = "default_false")]
2521 pub ca: bool,
2522 #[xmlserde(name = b"si", ty = "attr")]
2523 pub si: Option<u32>,
2524 #[xmlserde(name = b"bx", ty = "attr", default = "default_false")]
2525 pub bx: bool,
2526}