1#![allow(unused_variables)]
5#![allow(unused_imports)]
6#![allow(clippy::single_match)]
7#![allow(clippy::match_single_binding)]
8#![allow(clippy::manual_is_multiple_of)]
9
10use super::generated::*;
11use ooxml_dml::types::*;
12pub use ooxml_xml::{FromXml, ParseError};
13#[cfg(feature = "extra-children")]
14use ooxml_xml::{PositionedNode, RawXmlElement, RawXmlNode};
15use quick_xml::Reader;
16use quick_xml::events::{BytesStart, Event};
17use std::io::BufRead;
18
19#[allow(dead_code)]
20fn skip_element<R: BufRead>(reader: &mut Reader<R>) -> Result<(), ParseError> {
22 let mut depth = 1u32;
23 let mut buf = Vec::new();
24 loop {
25 match reader.read_event_into(&mut buf)? {
26 Event::Start(_) => depth += 1,
27 Event::End(_) => {
28 depth -= 1;
29 if depth == 0 {
30 break;
31 }
32 }
33 Event::Eof => break,
34 _ => {}
35 }
36 buf.clear();
37 }
38 Ok(())
39}
40
41#[allow(dead_code)]
42fn read_text_content<R: BufRead>(reader: &mut Reader<R>) -> Result<String, ParseError> {
44 let mut text = String::new();
45 let mut buf = Vec::new();
46 loop {
47 match reader.read_event_into(&mut buf)? {
48 Event::Text(e) => text.push_str(&e.decode().unwrap_or_default()),
49 Event::CData(e) => text.push_str(&e.decode().unwrap_or_default()),
50 Event::GeneralRef(e) => {
51 let name = e.decode().unwrap_or_default();
52 if let Some(s) = quick_xml::escape::resolve_xml_entity(&name) {
53 text.push_str(s);
54 }
55 }
56 Event::End(_) => break,
57 Event::Eof => break,
58 _ => {}
59 }
60 buf.clear();
61 }
62 Ok(text)
63}
64
65#[allow(dead_code)]
66fn decode_hex(s: &str) -> Option<Vec<u8>> {
68 let s = s.trim();
69 if s.len() % 2 != 0 {
70 return None;
71 }
72 (0..s.len())
73 .step_by(2)
74 .map(|i| u8::from_str_radix(&s[i..i + 2], 16).ok())
75 .collect()
76}
77
78#[allow(dead_code)]
79fn decode_base64(s: &str) -> Option<Vec<u8>> {
81 use base64::Engine;
82 base64::engine::general_purpose::STANDARD
83 .decode(s.trim())
84 .ok()
85}
86
87impl FromXml for CTSideDirectionTransition {
88 fn from_xml<R: BufRead>(
89 reader: &mut Reader<R>,
90 start_tag: &BytesStart,
91 is_empty: bool,
92 ) -> Result<Self, ParseError> {
93 let mut f_dir = None;
94 #[cfg(feature = "extra-attrs")]
95 let mut extra_attrs = std::collections::HashMap::new();
96
97 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
99 let val = String::from_utf8_lossy(&attr.value);
100 match attr.key.local_name().as_ref() {
101 b"dir" => {
102 f_dir = val.parse().ok();
103 }
104 #[cfg(feature = "extra-attrs")]
105 unknown => {
106 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
107 extra_attrs.insert(key, val.into_owned());
108 }
109 #[cfg(not(feature = "extra-attrs"))]
110 _ => {}
111 }
112 }
113
114 if !is_empty {
115 let mut buf = Vec::new();
116 loop {
117 match reader.read_event_into(&mut buf)? {
118 Event::End(_) => break,
119 Event::Eof => break,
120 _ => {}
121 }
122 buf.clear();
123 }
124 }
125
126 Ok(Self {
127 dir: f_dir,
128 #[cfg(feature = "extra-attrs")]
129 extra_attrs,
130 })
131 }
132}
133
134impl FromXml for CTCornerDirectionTransition {
135 fn from_xml<R: BufRead>(
136 reader: &mut Reader<R>,
137 start_tag: &BytesStart,
138 is_empty: bool,
139 ) -> Result<Self, ParseError> {
140 let mut f_dir = None;
141 #[cfg(feature = "extra-attrs")]
142 let mut extra_attrs = std::collections::HashMap::new();
143
144 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
146 let val = String::from_utf8_lossy(&attr.value);
147 match attr.key.local_name().as_ref() {
148 b"dir" => {
149 f_dir = val.parse().ok();
150 }
151 #[cfg(feature = "extra-attrs")]
152 unknown => {
153 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
154 extra_attrs.insert(key, val.into_owned());
155 }
156 #[cfg(not(feature = "extra-attrs"))]
157 _ => {}
158 }
159 }
160
161 if !is_empty {
162 let mut buf = Vec::new();
163 loop {
164 match reader.read_event_into(&mut buf)? {
165 Event::End(_) => break,
166 Event::Eof => break,
167 _ => {}
168 }
169 buf.clear();
170 }
171 }
172
173 Ok(Self {
174 dir: f_dir,
175 #[cfg(feature = "extra-attrs")]
176 extra_attrs,
177 })
178 }
179}
180
181impl FromXml for CTEightDirectionTransition {
182 fn from_xml<R: BufRead>(
183 reader: &mut Reader<R>,
184 start_tag: &BytesStart,
185 is_empty: bool,
186 ) -> Result<Self, ParseError> {
187 let mut f_dir = None;
188 #[cfg(feature = "extra-attrs")]
189 let mut extra_attrs = std::collections::HashMap::new();
190
191 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
193 let val = String::from_utf8_lossy(&attr.value);
194 match attr.key.local_name().as_ref() {
195 b"dir" => {
196 f_dir = Some(val.into_owned());
197 }
198 #[cfg(feature = "extra-attrs")]
199 unknown => {
200 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
201 extra_attrs.insert(key, val.into_owned());
202 }
203 #[cfg(not(feature = "extra-attrs"))]
204 _ => {}
205 }
206 }
207
208 if !is_empty {
209 let mut buf = Vec::new();
210 loop {
211 match reader.read_event_into(&mut buf)? {
212 Event::End(_) => break,
213 Event::Eof => break,
214 _ => {}
215 }
216 buf.clear();
217 }
218 }
219
220 Ok(Self {
221 dir: f_dir,
222 #[cfg(feature = "extra-attrs")]
223 extra_attrs,
224 })
225 }
226}
227
228impl FromXml for CTOrientationTransition {
229 fn from_xml<R: BufRead>(
230 reader: &mut Reader<R>,
231 start_tag: &BytesStart,
232 is_empty: bool,
233 ) -> Result<Self, ParseError> {
234 let mut f_dir = None;
235 #[cfg(feature = "extra-attrs")]
236 let mut extra_attrs = std::collections::HashMap::new();
237
238 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
240 let val = String::from_utf8_lossy(&attr.value);
241 match attr.key.local_name().as_ref() {
242 b"dir" => {
243 f_dir = val.parse().ok();
244 }
245 #[cfg(feature = "extra-attrs")]
246 unknown => {
247 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
248 extra_attrs.insert(key, val.into_owned());
249 }
250 #[cfg(not(feature = "extra-attrs"))]
251 _ => {}
252 }
253 }
254
255 if !is_empty {
256 let mut buf = Vec::new();
257 loop {
258 match reader.read_event_into(&mut buf)? {
259 Event::End(_) => break,
260 Event::Eof => break,
261 _ => {}
262 }
263 buf.clear();
264 }
265 }
266
267 Ok(Self {
268 dir: f_dir,
269 #[cfg(feature = "extra-attrs")]
270 extra_attrs,
271 })
272 }
273}
274
275impl FromXml for CTInOutTransition {
276 fn from_xml<R: BufRead>(
277 reader: &mut Reader<R>,
278 start_tag: &BytesStart,
279 is_empty: bool,
280 ) -> Result<Self, ParseError> {
281 let mut f_dir = None;
282 #[cfg(feature = "extra-attrs")]
283 let mut extra_attrs = std::collections::HashMap::new();
284
285 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
287 let val = String::from_utf8_lossy(&attr.value);
288 match attr.key.local_name().as_ref() {
289 b"dir" => {
290 f_dir = val.parse().ok();
291 }
292 #[cfg(feature = "extra-attrs")]
293 unknown => {
294 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
295 extra_attrs.insert(key, val.into_owned());
296 }
297 #[cfg(not(feature = "extra-attrs"))]
298 _ => {}
299 }
300 }
301
302 if !is_empty {
303 let mut buf = Vec::new();
304 loop {
305 match reader.read_event_into(&mut buf)? {
306 Event::End(_) => break,
307 Event::Eof => break,
308 _ => {}
309 }
310 buf.clear();
311 }
312 }
313
314 Ok(Self {
315 dir: f_dir,
316 #[cfg(feature = "extra-attrs")]
317 extra_attrs,
318 })
319 }
320}
321
322impl FromXml for CTOptionalBlackTransition {
323 fn from_xml<R: BufRead>(
324 reader: &mut Reader<R>,
325 start_tag: &BytesStart,
326 is_empty: bool,
327 ) -> Result<Self, ParseError> {
328 let mut f_thru_blk = None;
329 #[cfg(feature = "extra-attrs")]
330 let mut extra_attrs = std::collections::HashMap::new();
331
332 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
334 let val = String::from_utf8_lossy(&attr.value);
335 match attr.key.local_name().as_ref() {
336 b"thruBlk" => {
337 f_thru_blk = Some(val == "true" || val == "1");
338 }
339 #[cfg(feature = "extra-attrs")]
340 unknown => {
341 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
342 extra_attrs.insert(key, val.into_owned());
343 }
344 #[cfg(not(feature = "extra-attrs"))]
345 _ => {}
346 }
347 }
348
349 if !is_empty {
350 let mut buf = Vec::new();
351 loop {
352 match reader.read_event_into(&mut buf)? {
353 Event::End(_) => break,
354 Event::Eof => break,
355 _ => {}
356 }
357 buf.clear();
358 }
359 }
360
361 Ok(Self {
362 thru_blk: f_thru_blk,
363 #[cfg(feature = "extra-attrs")]
364 extra_attrs,
365 })
366 }
367}
368
369impl FromXml for CTSplitTransition {
370 fn from_xml<R: BufRead>(
371 reader: &mut Reader<R>,
372 start_tag: &BytesStart,
373 is_empty: bool,
374 ) -> Result<Self, ParseError> {
375 let mut f_orient = None;
376 let mut f_dir = None;
377 #[cfg(feature = "extra-attrs")]
378 let mut extra_attrs = std::collections::HashMap::new();
379
380 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
382 let val = String::from_utf8_lossy(&attr.value);
383 match attr.key.local_name().as_ref() {
384 b"orient" => {
385 f_orient = val.parse().ok();
386 }
387 b"dir" => {
388 f_dir = val.parse().ok();
389 }
390 #[cfg(feature = "extra-attrs")]
391 unknown => {
392 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
393 extra_attrs.insert(key, val.into_owned());
394 }
395 #[cfg(not(feature = "extra-attrs"))]
396 _ => {}
397 }
398 }
399
400 if !is_empty {
401 let mut buf = Vec::new();
402 loop {
403 match reader.read_event_into(&mut buf)? {
404 Event::End(_) => break,
405 Event::Eof => break,
406 _ => {}
407 }
408 buf.clear();
409 }
410 }
411
412 Ok(Self {
413 orient: f_orient,
414 dir: f_dir,
415 #[cfg(feature = "extra-attrs")]
416 extra_attrs,
417 })
418 }
419}
420
421impl FromXml for CTWheelTransition {
422 fn from_xml<R: BufRead>(
423 reader: &mut Reader<R>,
424 start_tag: &BytesStart,
425 is_empty: bool,
426 ) -> Result<Self, ParseError> {
427 let mut f_spokes = None;
428 #[cfg(feature = "extra-attrs")]
429 let mut extra_attrs = std::collections::HashMap::new();
430
431 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
433 let val = String::from_utf8_lossy(&attr.value);
434 match attr.key.local_name().as_ref() {
435 b"spokes" => {
436 f_spokes = val.parse().ok();
437 }
438 #[cfg(feature = "extra-attrs")]
439 unknown => {
440 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
441 extra_attrs.insert(key, val.into_owned());
442 }
443 #[cfg(not(feature = "extra-attrs"))]
444 _ => {}
445 }
446 }
447
448 if !is_empty {
449 let mut buf = Vec::new();
450 loop {
451 match reader.read_event_into(&mut buf)? {
452 Event::End(_) => break,
453 Event::Eof => break,
454 _ => {}
455 }
456 buf.clear();
457 }
458 }
459
460 Ok(Self {
461 spokes: f_spokes,
462 #[cfg(feature = "extra-attrs")]
463 extra_attrs,
464 })
465 }
466}
467
468impl FromXml for CTTransitionStartSoundAction {
469 fn from_xml<R: BufRead>(
470 reader: &mut Reader<R>,
471 start_tag: &BytesStart,
472 is_empty: bool,
473 ) -> Result<Self, ParseError> {
474 let mut f_loop = None;
475 let mut f_snd: Option<Box<ooxml_dml::types::CTEmbeddedWAVAudioFile>> = None;
476 #[cfg(feature = "extra-attrs")]
477 let mut extra_attrs = std::collections::HashMap::new();
478 #[cfg(feature = "extra-children")]
479 let mut extra_children = Vec::new();
480 #[cfg(feature = "extra-children")]
481 let mut child_idx: usize = 0;
482
483 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
485 let val = String::from_utf8_lossy(&attr.value);
486 match attr.key.local_name().as_ref() {
487 b"loop" => {
488 f_loop = Some(val == "true" || val == "1");
489 }
490 #[cfg(feature = "extra-attrs")]
491 unknown => {
492 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
493 extra_attrs.insert(key, val.into_owned());
494 }
495 #[cfg(not(feature = "extra-attrs"))]
496 _ => {}
497 }
498 }
499
500 if !is_empty {
502 let mut buf = Vec::new();
503 loop {
504 match reader.read_event_into(&mut buf)? {
505 Event::Start(e) => {
506 match e.local_name().as_ref() {
507 b"snd" => {
508 f_snd = Some(Box::new(
509 ooxml_dml::types::CTEmbeddedWAVAudioFile::from_xml(
510 reader, &e, false,
511 )?,
512 ));
513 #[cfg(feature = "extra-children")]
514 {
515 child_idx += 1;
516 }
517 }
518 #[cfg(feature = "extra-children")]
519 _ => {
520 let elem = RawXmlElement::from_reader(reader, &e)?;
522 extra_children.push(PositionedNode::new(
523 child_idx,
524 RawXmlNode::Element(elem),
525 ));
526 child_idx += 1;
527 }
528 #[cfg(not(feature = "extra-children"))]
529 _ => {
530 skip_element(reader)?;
532 }
533 }
534 }
535 Event::Empty(e) => {
536 match e.local_name().as_ref() {
537 b"snd" => {
538 f_snd = Some(Box::new(
539 ooxml_dml::types::CTEmbeddedWAVAudioFile::from_xml(
540 reader, &e, true,
541 )?,
542 ));
543 #[cfg(feature = "extra-children")]
544 {
545 child_idx += 1;
546 }
547 }
548 #[cfg(feature = "extra-children")]
549 _ => {
550 let elem = RawXmlElement::from_empty(&e);
552 extra_children.push(PositionedNode::new(
553 child_idx,
554 RawXmlNode::Element(elem),
555 ));
556 child_idx += 1;
557 }
558 #[cfg(not(feature = "extra-children"))]
559 _ => {}
560 }
561 }
562 Event::End(_) => break,
563 Event::Eof => break,
564 _ => {}
565 }
566 buf.clear();
567 }
568 }
569
570 Ok(Self {
571 r#loop: f_loop,
572 snd: f_snd.ok_or_else(|| ParseError::MissingAttribute("snd".to_string()))?,
573 #[cfg(feature = "extra-attrs")]
574 extra_attrs,
575 #[cfg(feature = "extra-children")]
576 extra_children,
577 })
578 }
579}
580
581impl FromXml for CTTransitionSoundAction {
582 fn from_xml<R: BufRead>(
583 reader: &mut Reader<R>,
584 start_tag: &BytesStart,
585 is_empty: bool,
586 ) -> Result<Self, ParseError> {
587 let mut f_st_snd = None;
588 let mut f_end_snd = None;
589 #[cfg(feature = "extra-children")]
590 let mut extra_children = Vec::new();
591 #[cfg(feature = "extra-children")]
592 let mut child_idx: usize = 0;
593
594 if !is_empty {
596 let mut buf = Vec::new();
597 loop {
598 match reader.read_event_into(&mut buf)? {
599 Event::Start(e) => {
600 match e.local_name().as_ref() {
601 b"stSnd" => {
602 f_st_snd = Some(Box::new(CTTransitionStartSoundAction::from_xml(
603 reader, &e, false,
604 )?));
605 #[cfg(feature = "extra-children")]
606 {
607 child_idx += 1;
608 }
609 }
610 b"endSnd" => {
611 f_end_snd = Some(Box::new(CTEmpty::from_xml(reader, &e, false)?));
612 #[cfg(feature = "extra-children")]
613 {
614 child_idx += 1;
615 }
616 }
617 #[cfg(feature = "extra-children")]
618 _ => {
619 let elem = RawXmlElement::from_reader(reader, &e)?;
621 extra_children.push(PositionedNode::new(
622 child_idx,
623 RawXmlNode::Element(elem),
624 ));
625 child_idx += 1;
626 }
627 #[cfg(not(feature = "extra-children"))]
628 _ => {
629 skip_element(reader)?;
631 }
632 }
633 }
634 Event::Empty(e) => {
635 match e.local_name().as_ref() {
636 b"stSnd" => {
637 f_st_snd = Some(Box::new(CTTransitionStartSoundAction::from_xml(
638 reader, &e, true,
639 )?));
640 #[cfg(feature = "extra-children")]
641 {
642 child_idx += 1;
643 }
644 }
645 b"endSnd" => {
646 f_end_snd = Some(Box::new(CTEmpty::from_xml(reader, &e, true)?));
647 #[cfg(feature = "extra-children")]
648 {
649 child_idx += 1;
650 }
651 }
652 #[cfg(feature = "extra-children")]
653 _ => {
654 let elem = RawXmlElement::from_empty(&e);
656 extra_children.push(PositionedNode::new(
657 child_idx,
658 RawXmlNode::Element(elem),
659 ));
660 child_idx += 1;
661 }
662 #[cfg(not(feature = "extra-children"))]
663 _ => {}
664 }
665 }
666 Event::End(_) => break,
667 Event::Eof => break,
668 _ => {}
669 }
670 buf.clear();
671 }
672 }
673
674 Ok(Self {
675 st_snd: f_st_snd,
676 end_snd: f_end_snd,
677 #[cfg(feature = "extra-children")]
678 extra_children,
679 })
680 }
681}
682
683impl FromXml for SlideTransition {
684 fn from_xml<R: BufRead>(
685 reader: &mut Reader<R>,
686 start_tag: &BytesStart,
687 is_empty: bool,
688 ) -> Result<Self, ParseError> {
689 #[cfg(feature = "pml-transitions")]
690 let mut f_spd = None;
691 #[cfg(feature = "pml-transitions")]
692 let mut f_adv_click = None;
693 #[cfg(feature = "pml-transitions")]
694 let mut f_adv_tm = None;
695 #[cfg(feature = "pml-transitions")]
696 let mut f_blinds = None;
697 #[cfg(feature = "pml-transitions")]
698 let mut f_checker = None;
699 #[cfg(feature = "pml-transitions")]
700 let mut f_circle = None;
701 #[cfg(feature = "pml-transitions")]
702 let mut f_dissolve = None;
703 #[cfg(feature = "pml-transitions")]
704 let mut f_comb = None;
705 #[cfg(feature = "pml-transitions")]
706 let mut f_cover = None;
707 #[cfg(feature = "pml-transitions")]
708 let mut f_cut = None;
709 #[cfg(feature = "pml-transitions")]
710 let mut f_diamond = None;
711 #[cfg(feature = "pml-transitions")]
712 let mut f_fade = None;
713 #[cfg(feature = "pml-transitions")]
714 let mut f_newsflash = None;
715 #[cfg(feature = "pml-transitions")]
716 let mut f_plus = None;
717 #[cfg(feature = "pml-transitions")]
718 let mut f_pull = None;
719 #[cfg(feature = "pml-transitions")]
720 let mut f_push = None;
721 #[cfg(feature = "pml-transitions")]
722 let mut f_random = None;
723 #[cfg(feature = "pml-transitions")]
724 let mut f_random_bar = None;
725 #[cfg(feature = "pml-transitions")]
726 let mut f_split = None;
727 #[cfg(feature = "pml-transitions")]
728 let mut f_strips = None;
729 #[cfg(feature = "pml-transitions")]
730 let mut f_wedge = None;
731 #[cfg(feature = "pml-transitions")]
732 let mut f_wheel = None;
733 #[cfg(feature = "pml-transitions")]
734 let mut f_wipe = None;
735 #[cfg(feature = "pml-transitions")]
736 let mut f_zoom = None;
737 #[cfg(feature = "pml-transitions")]
738 let mut f_snd_ac = None;
739 #[cfg(feature = "pml-extensions")]
740 let mut f_ext_lst = None;
741 #[cfg(feature = "extra-attrs")]
742 let mut extra_attrs = std::collections::HashMap::new();
743 #[cfg(feature = "extra-children")]
744 let mut extra_children = Vec::new();
745 #[cfg(feature = "extra-children")]
746 let mut child_idx: usize = 0;
747
748 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
750 let val = String::from_utf8_lossy(&attr.value);
751 match attr.key.local_name().as_ref() {
752 #[cfg(feature = "pml-transitions")]
753 b"spd" => {
754 f_spd = val.parse().ok();
755 }
756 #[cfg(feature = "pml-transitions")]
757 b"advClick" => {
758 f_adv_click = Some(val == "true" || val == "1");
759 }
760 #[cfg(feature = "pml-transitions")]
761 b"advTm" => {
762 f_adv_tm = val.parse().ok();
763 }
764 #[cfg(feature = "extra-attrs")]
765 unknown => {
766 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
767 extra_attrs.insert(key, val.into_owned());
768 }
769 #[cfg(not(feature = "extra-attrs"))]
770 _ => {}
771 }
772 }
773
774 if !is_empty {
776 let mut buf = Vec::new();
777 loop {
778 match reader.read_event_into(&mut buf)? {
779 Event::Start(e) => {
780 match e.local_name().as_ref() {
781 #[cfg(feature = "pml-transitions")]
782 b"blinds" => {
783 f_blinds = Some(Box::new(CTOrientationTransition::from_xml(
784 reader, &e, false,
785 )?));
786 #[cfg(feature = "extra-children")]
787 {
788 child_idx += 1;
789 }
790 }
791 #[cfg(feature = "pml-transitions")]
792 b"checker" => {
793 f_checker = Some(Box::new(CTOrientationTransition::from_xml(
794 reader, &e, false,
795 )?));
796 #[cfg(feature = "extra-children")]
797 {
798 child_idx += 1;
799 }
800 }
801 #[cfg(feature = "pml-transitions")]
802 b"circle" => {
803 f_circle = Some(Box::new(CTEmpty::from_xml(reader, &e, false)?));
804 #[cfg(feature = "extra-children")]
805 {
806 child_idx += 1;
807 }
808 }
809 #[cfg(feature = "pml-transitions")]
810 b"dissolve" => {
811 f_dissolve = Some(Box::new(CTEmpty::from_xml(reader, &e, false)?));
812 #[cfg(feature = "extra-children")]
813 {
814 child_idx += 1;
815 }
816 }
817 #[cfg(feature = "pml-transitions")]
818 b"comb" => {
819 f_comb = Some(Box::new(CTOrientationTransition::from_xml(
820 reader, &e, false,
821 )?));
822 #[cfg(feature = "extra-children")]
823 {
824 child_idx += 1;
825 }
826 }
827 #[cfg(feature = "pml-transitions")]
828 b"cover" => {
829 f_cover = Some(Box::new(CTEightDirectionTransition::from_xml(
830 reader, &e, false,
831 )?));
832 #[cfg(feature = "extra-children")]
833 {
834 child_idx += 1;
835 }
836 }
837 #[cfg(feature = "pml-transitions")]
838 b"cut" => {
839 f_cut = Some(Box::new(CTOptionalBlackTransition::from_xml(
840 reader, &e, false,
841 )?));
842 #[cfg(feature = "extra-children")]
843 {
844 child_idx += 1;
845 }
846 }
847 #[cfg(feature = "pml-transitions")]
848 b"diamond" => {
849 f_diamond = Some(Box::new(CTEmpty::from_xml(reader, &e, false)?));
850 #[cfg(feature = "extra-children")]
851 {
852 child_idx += 1;
853 }
854 }
855 #[cfg(feature = "pml-transitions")]
856 b"fade" => {
857 f_fade = Some(Box::new(CTOptionalBlackTransition::from_xml(
858 reader, &e, false,
859 )?));
860 #[cfg(feature = "extra-children")]
861 {
862 child_idx += 1;
863 }
864 }
865 #[cfg(feature = "pml-transitions")]
866 b"newsflash" => {
867 f_newsflash = Some(Box::new(CTEmpty::from_xml(reader, &e, false)?));
868 #[cfg(feature = "extra-children")]
869 {
870 child_idx += 1;
871 }
872 }
873 #[cfg(feature = "pml-transitions")]
874 b"plus" => {
875 f_plus = Some(Box::new(CTEmpty::from_xml(reader, &e, false)?));
876 #[cfg(feature = "extra-children")]
877 {
878 child_idx += 1;
879 }
880 }
881 #[cfg(feature = "pml-transitions")]
882 b"pull" => {
883 f_pull = Some(Box::new(CTEightDirectionTransition::from_xml(
884 reader, &e, false,
885 )?));
886 #[cfg(feature = "extra-children")]
887 {
888 child_idx += 1;
889 }
890 }
891 #[cfg(feature = "pml-transitions")]
892 b"push" => {
893 f_push = Some(Box::new(CTSideDirectionTransition::from_xml(
894 reader, &e, false,
895 )?));
896 #[cfg(feature = "extra-children")]
897 {
898 child_idx += 1;
899 }
900 }
901 #[cfg(feature = "pml-transitions")]
902 b"random" => {
903 f_random = Some(Box::new(CTEmpty::from_xml(reader, &e, false)?));
904 #[cfg(feature = "extra-children")]
905 {
906 child_idx += 1;
907 }
908 }
909 #[cfg(feature = "pml-transitions")]
910 b"randomBar" => {
911 f_random_bar = Some(Box::new(CTOrientationTransition::from_xml(
912 reader, &e, false,
913 )?));
914 #[cfg(feature = "extra-children")]
915 {
916 child_idx += 1;
917 }
918 }
919 #[cfg(feature = "pml-transitions")]
920 b"split" => {
921 f_split =
922 Some(Box::new(CTSplitTransition::from_xml(reader, &e, false)?));
923 #[cfg(feature = "extra-children")]
924 {
925 child_idx += 1;
926 }
927 }
928 #[cfg(feature = "pml-transitions")]
929 b"strips" => {
930 f_strips = Some(Box::new(CTCornerDirectionTransition::from_xml(
931 reader, &e, false,
932 )?));
933 #[cfg(feature = "extra-children")]
934 {
935 child_idx += 1;
936 }
937 }
938 #[cfg(feature = "pml-transitions")]
939 b"wedge" => {
940 f_wedge = Some(Box::new(CTEmpty::from_xml(reader, &e, false)?));
941 #[cfg(feature = "extra-children")]
942 {
943 child_idx += 1;
944 }
945 }
946 #[cfg(feature = "pml-transitions")]
947 b"wheel" => {
948 f_wheel =
949 Some(Box::new(CTWheelTransition::from_xml(reader, &e, false)?));
950 #[cfg(feature = "extra-children")]
951 {
952 child_idx += 1;
953 }
954 }
955 #[cfg(feature = "pml-transitions")]
956 b"wipe" => {
957 f_wipe = Some(Box::new(CTSideDirectionTransition::from_xml(
958 reader, &e, false,
959 )?));
960 #[cfg(feature = "extra-children")]
961 {
962 child_idx += 1;
963 }
964 }
965 #[cfg(feature = "pml-transitions")]
966 b"zoom" => {
967 f_zoom =
968 Some(Box::new(CTInOutTransition::from_xml(reader, &e, false)?));
969 #[cfg(feature = "extra-children")]
970 {
971 child_idx += 1;
972 }
973 }
974 #[cfg(feature = "pml-transitions")]
975 b"sndAc" => {
976 f_snd_ac = Some(Box::new(CTTransitionSoundAction::from_xml(
977 reader, &e, false,
978 )?));
979 #[cfg(feature = "extra-children")]
980 {
981 child_idx += 1;
982 }
983 }
984 #[cfg(feature = "pml-extensions")]
985 b"extLst" => {
986 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
987 reader, &e, false,
988 )?));
989 #[cfg(feature = "extra-children")]
990 {
991 child_idx += 1;
992 }
993 }
994 #[cfg(feature = "extra-children")]
995 _ => {
996 let elem = RawXmlElement::from_reader(reader, &e)?;
998 extra_children.push(PositionedNode::new(
999 child_idx,
1000 RawXmlNode::Element(elem),
1001 ));
1002 child_idx += 1;
1003 }
1004 #[cfg(not(feature = "extra-children"))]
1005 _ => {
1006 skip_element(reader)?;
1008 }
1009 }
1010 }
1011 Event::Empty(e) => {
1012 match e.local_name().as_ref() {
1013 #[cfg(feature = "pml-transitions")]
1014 b"blinds" => {
1015 f_blinds = Some(Box::new(CTOrientationTransition::from_xml(
1016 reader, &e, true,
1017 )?));
1018 #[cfg(feature = "extra-children")]
1019 {
1020 child_idx += 1;
1021 }
1022 }
1023 #[cfg(feature = "pml-transitions")]
1024 b"checker" => {
1025 f_checker = Some(Box::new(CTOrientationTransition::from_xml(
1026 reader, &e, true,
1027 )?));
1028 #[cfg(feature = "extra-children")]
1029 {
1030 child_idx += 1;
1031 }
1032 }
1033 #[cfg(feature = "pml-transitions")]
1034 b"circle" => {
1035 f_circle = Some(Box::new(CTEmpty::from_xml(reader, &e, true)?));
1036 #[cfg(feature = "extra-children")]
1037 {
1038 child_idx += 1;
1039 }
1040 }
1041 #[cfg(feature = "pml-transitions")]
1042 b"dissolve" => {
1043 f_dissolve = Some(Box::new(CTEmpty::from_xml(reader, &e, true)?));
1044 #[cfg(feature = "extra-children")]
1045 {
1046 child_idx += 1;
1047 }
1048 }
1049 #[cfg(feature = "pml-transitions")]
1050 b"comb" => {
1051 f_comb = Some(Box::new(CTOrientationTransition::from_xml(
1052 reader, &e, true,
1053 )?));
1054 #[cfg(feature = "extra-children")]
1055 {
1056 child_idx += 1;
1057 }
1058 }
1059 #[cfg(feature = "pml-transitions")]
1060 b"cover" => {
1061 f_cover = Some(Box::new(CTEightDirectionTransition::from_xml(
1062 reader, &e, true,
1063 )?));
1064 #[cfg(feature = "extra-children")]
1065 {
1066 child_idx += 1;
1067 }
1068 }
1069 #[cfg(feature = "pml-transitions")]
1070 b"cut" => {
1071 f_cut = Some(Box::new(CTOptionalBlackTransition::from_xml(
1072 reader, &e, true,
1073 )?));
1074 #[cfg(feature = "extra-children")]
1075 {
1076 child_idx += 1;
1077 }
1078 }
1079 #[cfg(feature = "pml-transitions")]
1080 b"diamond" => {
1081 f_diamond = Some(Box::new(CTEmpty::from_xml(reader, &e, true)?));
1082 #[cfg(feature = "extra-children")]
1083 {
1084 child_idx += 1;
1085 }
1086 }
1087 #[cfg(feature = "pml-transitions")]
1088 b"fade" => {
1089 f_fade = Some(Box::new(CTOptionalBlackTransition::from_xml(
1090 reader, &e, true,
1091 )?));
1092 #[cfg(feature = "extra-children")]
1093 {
1094 child_idx += 1;
1095 }
1096 }
1097 #[cfg(feature = "pml-transitions")]
1098 b"newsflash" => {
1099 f_newsflash = Some(Box::new(CTEmpty::from_xml(reader, &e, true)?));
1100 #[cfg(feature = "extra-children")]
1101 {
1102 child_idx += 1;
1103 }
1104 }
1105 #[cfg(feature = "pml-transitions")]
1106 b"plus" => {
1107 f_plus = Some(Box::new(CTEmpty::from_xml(reader, &e, true)?));
1108 #[cfg(feature = "extra-children")]
1109 {
1110 child_idx += 1;
1111 }
1112 }
1113 #[cfg(feature = "pml-transitions")]
1114 b"pull" => {
1115 f_pull = Some(Box::new(CTEightDirectionTransition::from_xml(
1116 reader, &e, true,
1117 )?));
1118 #[cfg(feature = "extra-children")]
1119 {
1120 child_idx += 1;
1121 }
1122 }
1123 #[cfg(feature = "pml-transitions")]
1124 b"push" => {
1125 f_push = Some(Box::new(CTSideDirectionTransition::from_xml(
1126 reader, &e, true,
1127 )?));
1128 #[cfg(feature = "extra-children")]
1129 {
1130 child_idx += 1;
1131 }
1132 }
1133 #[cfg(feature = "pml-transitions")]
1134 b"random" => {
1135 f_random = Some(Box::new(CTEmpty::from_xml(reader, &e, true)?));
1136 #[cfg(feature = "extra-children")]
1137 {
1138 child_idx += 1;
1139 }
1140 }
1141 #[cfg(feature = "pml-transitions")]
1142 b"randomBar" => {
1143 f_random_bar = Some(Box::new(CTOrientationTransition::from_xml(
1144 reader, &e, true,
1145 )?));
1146 #[cfg(feature = "extra-children")]
1147 {
1148 child_idx += 1;
1149 }
1150 }
1151 #[cfg(feature = "pml-transitions")]
1152 b"split" => {
1153 f_split =
1154 Some(Box::new(CTSplitTransition::from_xml(reader, &e, true)?));
1155 #[cfg(feature = "extra-children")]
1156 {
1157 child_idx += 1;
1158 }
1159 }
1160 #[cfg(feature = "pml-transitions")]
1161 b"strips" => {
1162 f_strips = Some(Box::new(CTCornerDirectionTransition::from_xml(
1163 reader, &e, true,
1164 )?));
1165 #[cfg(feature = "extra-children")]
1166 {
1167 child_idx += 1;
1168 }
1169 }
1170 #[cfg(feature = "pml-transitions")]
1171 b"wedge" => {
1172 f_wedge = Some(Box::new(CTEmpty::from_xml(reader, &e, true)?));
1173 #[cfg(feature = "extra-children")]
1174 {
1175 child_idx += 1;
1176 }
1177 }
1178 #[cfg(feature = "pml-transitions")]
1179 b"wheel" => {
1180 f_wheel =
1181 Some(Box::new(CTWheelTransition::from_xml(reader, &e, true)?));
1182 #[cfg(feature = "extra-children")]
1183 {
1184 child_idx += 1;
1185 }
1186 }
1187 #[cfg(feature = "pml-transitions")]
1188 b"wipe" => {
1189 f_wipe = Some(Box::new(CTSideDirectionTransition::from_xml(
1190 reader, &e, true,
1191 )?));
1192 #[cfg(feature = "extra-children")]
1193 {
1194 child_idx += 1;
1195 }
1196 }
1197 #[cfg(feature = "pml-transitions")]
1198 b"zoom" => {
1199 f_zoom =
1200 Some(Box::new(CTInOutTransition::from_xml(reader, &e, true)?));
1201 #[cfg(feature = "extra-children")]
1202 {
1203 child_idx += 1;
1204 }
1205 }
1206 #[cfg(feature = "pml-transitions")]
1207 b"sndAc" => {
1208 f_snd_ac = Some(Box::new(CTTransitionSoundAction::from_xml(
1209 reader, &e, true,
1210 )?));
1211 #[cfg(feature = "extra-children")]
1212 {
1213 child_idx += 1;
1214 }
1215 }
1216 #[cfg(feature = "pml-extensions")]
1217 b"extLst" => {
1218 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
1219 reader, &e, true,
1220 )?));
1221 #[cfg(feature = "extra-children")]
1222 {
1223 child_idx += 1;
1224 }
1225 }
1226 #[cfg(feature = "extra-children")]
1227 _ => {
1228 let elem = RawXmlElement::from_empty(&e);
1230 extra_children.push(PositionedNode::new(
1231 child_idx,
1232 RawXmlNode::Element(elem),
1233 ));
1234 child_idx += 1;
1235 }
1236 #[cfg(not(feature = "extra-children"))]
1237 _ => {}
1238 }
1239 }
1240 Event::End(_) => break,
1241 Event::Eof => break,
1242 _ => {}
1243 }
1244 buf.clear();
1245 }
1246 }
1247
1248 Ok(Self {
1249 #[cfg(feature = "pml-transitions")]
1250 spd: f_spd,
1251 #[cfg(feature = "pml-transitions")]
1252 adv_click: f_adv_click,
1253 #[cfg(feature = "pml-transitions")]
1254 adv_tm: f_adv_tm,
1255 #[cfg(feature = "pml-transitions")]
1256 blinds: f_blinds,
1257 #[cfg(feature = "pml-transitions")]
1258 checker: f_checker,
1259 #[cfg(feature = "pml-transitions")]
1260 circle: f_circle,
1261 #[cfg(feature = "pml-transitions")]
1262 dissolve: f_dissolve,
1263 #[cfg(feature = "pml-transitions")]
1264 comb: f_comb,
1265 #[cfg(feature = "pml-transitions")]
1266 cover: f_cover,
1267 #[cfg(feature = "pml-transitions")]
1268 cut: f_cut,
1269 #[cfg(feature = "pml-transitions")]
1270 diamond: f_diamond,
1271 #[cfg(feature = "pml-transitions")]
1272 fade: f_fade,
1273 #[cfg(feature = "pml-transitions")]
1274 newsflash: f_newsflash,
1275 #[cfg(feature = "pml-transitions")]
1276 plus: f_plus,
1277 #[cfg(feature = "pml-transitions")]
1278 pull: f_pull,
1279 #[cfg(feature = "pml-transitions")]
1280 push: f_push,
1281 #[cfg(feature = "pml-transitions")]
1282 random: f_random,
1283 #[cfg(feature = "pml-transitions")]
1284 random_bar: f_random_bar,
1285 #[cfg(feature = "pml-transitions")]
1286 split: f_split,
1287 #[cfg(feature = "pml-transitions")]
1288 strips: f_strips,
1289 #[cfg(feature = "pml-transitions")]
1290 wedge: f_wedge,
1291 #[cfg(feature = "pml-transitions")]
1292 wheel: f_wheel,
1293 #[cfg(feature = "pml-transitions")]
1294 wipe: f_wipe,
1295 #[cfg(feature = "pml-transitions")]
1296 zoom: f_zoom,
1297 #[cfg(feature = "pml-transitions")]
1298 snd_ac: f_snd_ac,
1299 #[cfg(feature = "pml-extensions")]
1300 ext_lst: f_ext_lst,
1301 #[cfg(feature = "extra-attrs")]
1302 extra_attrs,
1303 #[cfg(feature = "extra-children")]
1304 extra_children,
1305 })
1306 }
1307}
1308
1309impl FromXml for CTTLIterateIntervalTime {
1310 fn from_xml<R: BufRead>(
1311 reader: &mut Reader<R>,
1312 start_tag: &BytesStart,
1313 is_empty: bool,
1314 ) -> Result<Self, ParseError> {
1315 let mut f_value: Option<STTLTime> = None;
1316 #[cfg(feature = "extra-attrs")]
1317 let mut extra_attrs = std::collections::HashMap::new();
1318
1319 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
1321 let val = String::from_utf8_lossy(&attr.value);
1322 match attr.key.local_name().as_ref() {
1323 b"val" => {
1324 f_value = Some(val.into_owned());
1325 }
1326 #[cfg(feature = "extra-attrs")]
1327 unknown => {
1328 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
1329 extra_attrs.insert(key, val.into_owned());
1330 }
1331 #[cfg(not(feature = "extra-attrs"))]
1332 _ => {}
1333 }
1334 }
1335
1336 if !is_empty {
1337 let mut buf = Vec::new();
1338 loop {
1339 match reader.read_event_into(&mut buf)? {
1340 Event::End(_) => break,
1341 Event::Eof => break,
1342 _ => {}
1343 }
1344 buf.clear();
1345 }
1346 }
1347
1348 Ok(Self {
1349 value: f_value.ok_or_else(|| ParseError::MissingAttribute("val".to_string()))?,
1350 #[cfg(feature = "extra-attrs")]
1351 extra_attrs,
1352 })
1353 }
1354}
1355
1356impl FromXml for CTTLIterateIntervalPercentage {
1357 fn from_xml<R: BufRead>(
1358 reader: &mut Reader<R>,
1359 start_tag: &BytesStart,
1360 is_empty: bool,
1361 ) -> Result<Self, ParseError> {
1362 let mut f_value: Option<ooxml_dml::types::STPositivePercentage> = None;
1363 #[cfg(feature = "extra-attrs")]
1364 let mut extra_attrs = std::collections::HashMap::new();
1365
1366 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
1368 let val = String::from_utf8_lossy(&attr.value);
1369 match attr.key.local_name().as_ref() {
1370 b"val" => {
1371 f_value = val.parse().ok();
1372 }
1373 #[cfg(feature = "extra-attrs")]
1374 unknown => {
1375 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
1376 extra_attrs.insert(key, val.into_owned());
1377 }
1378 #[cfg(not(feature = "extra-attrs"))]
1379 _ => {}
1380 }
1381 }
1382
1383 if !is_empty {
1384 let mut buf = Vec::new();
1385 loop {
1386 match reader.read_event_into(&mut buf)? {
1387 Event::End(_) => break,
1388 Event::Eof => break,
1389 _ => {}
1390 }
1391 buf.clear();
1392 }
1393 }
1394
1395 Ok(Self {
1396 value: f_value.ok_or_else(|| ParseError::MissingAttribute("val".to_string()))?,
1397 #[cfg(feature = "extra-attrs")]
1398 extra_attrs,
1399 })
1400 }
1401}
1402
1403impl FromXml for CTTLIterateData {
1404 fn from_xml<R: BufRead>(
1405 reader: &mut Reader<R>,
1406 start_tag: &BytesStart,
1407 is_empty: bool,
1408 ) -> Result<Self, ParseError> {
1409 let mut f_type = None;
1410 let mut f_backwards = None;
1411 let mut f_tm_abs = None;
1412 let mut f_tm_pct = None;
1413 #[cfg(feature = "extra-attrs")]
1414 let mut extra_attrs = std::collections::HashMap::new();
1415 #[cfg(feature = "extra-children")]
1416 let mut extra_children = Vec::new();
1417 #[cfg(feature = "extra-children")]
1418 let mut child_idx: usize = 0;
1419
1420 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
1422 let val = String::from_utf8_lossy(&attr.value);
1423 match attr.key.local_name().as_ref() {
1424 b"type" => {
1425 f_type = val.parse().ok();
1426 }
1427 b"backwards" => {
1428 f_backwards = Some(val == "true" || val == "1");
1429 }
1430 #[cfg(feature = "extra-attrs")]
1431 unknown => {
1432 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
1433 extra_attrs.insert(key, val.into_owned());
1434 }
1435 #[cfg(not(feature = "extra-attrs"))]
1436 _ => {}
1437 }
1438 }
1439
1440 if !is_empty {
1442 let mut buf = Vec::new();
1443 loop {
1444 match reader.read_event_into(&mut buf)? {
1445 Event::Start(e) => {
1446 match e.local_name().as_ref() {
1447 b"tmAbs" => {
1448 f_tm_abs = Some(Box::new(CTTLIterateIntervalTime::from_xml(
1449 reader, &e, false,
1450 )?));
1451 #[cfg(feature = "extra-children")]
1452 {
1453 child_idx += 1;
1454 }
1455 }
1456 b"tmPct" => {
1457 f_tm_pct = Some(Box::new(CTTLIterateIntervalPercentage::from_xml(
1458 reader, &e, false,
1459 )?));
1460 #[cfg(feature = "extra-children")]
1461 {
1462 child_idx += 1;
1463 }
1464 }
1465 #[cfg(feature = "extra-children")]
1466 _ => {
1467 let elem = RawXmlElement::from_reader(reader, &e)?;
1469 extra_children.push(PositionedNode::new(
1470 child_idx,
1471 RawXmlNode::Element(elem),
1472 ));
1473 child_idx += 1;
1474 }
1475 #[cfg(not(feature = "extra-children"))]
1476 _ => {
1477 skip_element(reader)?;
1479 }
1480 }
1481 }
1482 Event::Empty(e) => {
1483 match e.local_name().as_ref() {
1484 b"tmAbs" => {
1485 f_tm_abs = Some(Box::new(CTTLIterateIntervalTime::from_xml(
1486 reader, &e, true,
1487 )?));
1488 #[cfg(feature = "extra-children")]
1489 {
1490 child_idx += 1;
1491 }
1492 }
1493 b"tmPct" => {
1494 f_tm_pct = Some(Box::new(CTTLIterateIntervalPercentage::from_xml(
1495 reader, &e, true,
1496 )?));
1497 #[cfg(feature = "extra-children")]
1498 {
1499 child_idx += 1;
1500 }
1501 }
1502 #[cfg(feature = "extra-children")]
1503 _ => {
1504 let elem = RawXmlElement::from_empty(&e);
1506 extra_children.push(PositionedNode::new(
1507 child_idx,
1508 RawXmlNode::Element(elem),
1509 ));
1510 child_idx += 1;
1511 }
1512 #[cfg(not(feature = "extra-children"))]
1513 _ => {}
1514 }
1515 }
1516 Event::End(_) => break,
1517 Event::Eof => break,
1518 _ => {}
1519 }
1520 buf.clear();
1521 }
1522 }
1523
1524 Ok(Self {
1525 r#type: f_type,
1526 backwards: f_backwards,
1527 tm_abs: f_tm_abs,
1528 tm_pct: f_tm_pct,
1529 #[cfg(feature = "extra-attrs")]
1530 extra_attrs,
1531 #[cfg(feature = "extra-children")]
1532 extra_children,
1533 })
1534 }
1535}
1536
1537impl FromXml for CTTLSubShapeId {
1538 fn from_xml<R: BufRead>(
1539 reader: &mut Reader<R>,
1540 start_tag: &BytesStart,
1541 is_empty: bool,
1542 ) -> Result<Self, ParseError> {
1543 let mut f_spid: Option<ooxml_dml::types::STShapeID> = None;
1544 #[cfg(feature = "extra-attrs")]
1545 let mut extra_attrs = std::collections::HashMap::new();
1546
1547 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
1549 let val = String::from_utf8_lossy(&attr.value);
1550 match attr.key.local_name().as_ref() {
1551 b"spid" => {
1552 f_spid = val.parse().ok();
1553 }
1554 #[cfg(feature = "extra-attrs")]
1555 unknown => {
1556 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
1557 extra_attrs.insert(key, val.into_owned());
1558 }
1559 #[cfg(not(feature = "extra-attrs"))]
1560 _ => {}
1561 }
1562 }
1563
1564 if !is_empty {
1565 let mut buf = Vec::new();
1566 loop {
1567 match reader.read_event_into(&mut buf)? {
1568 Event::End(_) => break,
1569 Event::Eof => break,
1570 _ => {}
1571 }
1572 buf.clear();
1573 }
1574 }
1575
1576 Ok(Self {
1577 spid: f_spid.ok_or_else(|| ParseError::MissingAttribute("spid".to_string()))?,
1578 #[cfg(feature = "extra-attrs")]
1579 extra_attrs,
1580 })
1581 }
1582}
1583
1584impl FromXml for CTTLTextTargetElement {
1585 fn from_xml<R: BufRead>(
1586 reader: &mut Reader<R>,
1587 start_tag: &BytesStart,
1588 is_empty: bool,
1589 ) -> Result<Self, ParseError> {
1590 let mut f_char_rg = None;
1591 let mut f_p_rg = None;
1592 #[cfg(feature = "extra-children")]
1593 let mut extra_children = Vec::new();
1594 #[cfg(feature = "extra-children")]
1595 let mut child_idx: usize = 0;
1596
1597 if !is_empty {
1599 let mut buf = Vec::new();
1600 loop {
1601 match reader.read_event_into(&mut buf)? {
1602 Event::Start(e) => {
1603 match e.local_name().as_ref() {
1604 b"charRg" => {
1605 f_char_rg =
1606 Some(Box::new(CTIndexRange::from_xml(reader, &e, false)?));
1607 #[cfg(feature = "extra-children")]
1608 {
1609 child_idx += 1;
1610 }
1611 }
1612 b"pRg" => {
1613 f_p_rg = Some(Box::new(CTIndexRange::from_xml(reader, &e, false)?));
1614 #[cfg(feature = "extra-children")]
1615 {
1616 child_idx += 1;
1617 }
1618 }
1619 #[cfg(feature = "extra-children")]
1620 _ => {
1621 let elem = RawXmlElement::from_reader(reader, &e)?;
1623 extra_children.push(PositionedNode::new(
1624 child_idx,
1625 RawXmlNode::Element(elem),
1626 ));
1627 child_idx += 1;
1628 }
1629 #[cfg(not(feature = "extra-children"))]
1630 _ => {
1631 skip_element(reader)?;
1633 }
1634 }
1635 }
1636 Event::Empty(e) => {
1637 match e.local_name().as_ref() {
1638 b"charRg" => {
1639 f_char_rg =
1640 Some(Box::new(CTIndexRange::from_xml(reader, &e, true)?));
1641 #[cfg(feature = "extra-children")]
1642 {
1643 child_idx += 1;
1644 }
1645 }
1646 b"pRg" => {
1647 f_p_rg = Some(Box::new(CTIndexRange::from_xml(reader, &e, true)?));
1648 #[cfg(feature = "extra-children")]
1649 {
1650 child_idx += 1;
1651 }
1652 }
1653 #[cfg(feature = "extra-children")]
1654 _ => {
1655 let elem = RawXmlElement::from_empty(&e);
1657 extra_children.push(PositionedNode::new(
1658 child_idx,
1659 RawXmlNode::Element(elem),
1660 ));
1661 child_idx += 1;
1662 }
1663 #[cfg(not(feature = "extra-children"))]
1664 _ => {}
1665 }
1666 }
1667 Event::End(_) => break,
1668 Event::Eof => break,
1669 _ => {}
1670 }
1671 buf.clear();
1672 }
1673 }
1674
1675 Ok(Self {
1676 char_rg: f_char_rg,
1677 p_rg: f_p_rg,
1678 #[cfg(feature = "extra-children")]
1679 extra_children,
1680 })
1681 }
1682}
1683
1684impl FromXml for CTTLOleChartTargetElement {
1685 fn from_xml<R: BufRead>(
1686 reader: &mut Reader<R>,
1687 start_tag: &BytesStart,
1688 is_empty: bool,
1689 ) -> Result<Self, ParseError> {
1690 let mut f_type: Option<STTLChartSubelementType> = None;
1691 let mut f_lvl = None;
1692 #[cfg(feature = "extra-attrs")]
1693 let mut extra_attrs = std::collections::HashMap::new();
1694
1695 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
1697 let val = String::from_utf8_lossy(&attr.value);
1698 match attr.key.local_name().as_ref() {
1699 b"type" => {
1700 f_type = val.parse().ok();
1701 }
1702 b"lvl" => {
1703 f_lvl = val.parse().ok();
1704 }
1705 #[cfg(feature = "extra-attrs")]
1706 unknown => {
1707 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
1708 extra_attrs.insert(key, val.into_owned());
1709 }
1710 #[cfg(not(feature = "extra-attrs"))]
1711 _ => {}
1712 }
1713 }
1714
1715 if !is_empty {
1716 let mut buf = Vec::new();
1717 loop {
1718 match reader.read_event_into(&mut buf)? {
1719 Event::End(_) => break,
1720 Event::Eof => break,
1721 _ => {}
1722 }
1723 buf.clear();
1724 }
1725 }
1726
1727 Ok(Self {
1728 r#type: f_type.ok_or_else(|| ParseError::MissingAttribute("type".to_string()))?,
1729 lvl: f_lvl,
1730 #[cfg(feature = "extra-attrs")]
1731 extra_attrs,
1732 })
1733 }
1734}
1735
1736impl FromXml for CTTLShapeTargetElement {
1737 fn from_xml<R: BufRead>(
1738 reader: &mut Reader<R>,
1739 start_tag: &BytesStart,
1740 is_empty: bool,
1741 ) -> Result<Self, ParseError> {
1742 let mut f_spid: Option<ooxml_dml::types::STDrawingElementId> = None;
1743 let mut f_bg = None;
1744 let mut f_sub_sp = None;
1745 let mut f_ole_chart_el = None;
1746 let mut f_tx_el = None;
1747 let mut f_graphic_el = None;
1748 #[cfg(feature = "extra-attrs")]
1749 let mut extra_attrs = std::collections::HashMap::new();
1750 #[cfg(feature = "extra-children")]
1751 let mut extra_children = Vec::new();
1752 #[cfg(feature = "extra-children")]
1753 let mut child_idx: usize = 0;
1754
1755 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
1757 let val = String::from_utf8_lossy(&attr.value);
1758 match attr.key.local_name().as_ref() {
1759 b"spid" => {
1760 f_spid = val.parse().ok();
1761 }
1762 #[cfg(feature = "extra-attrs")]
1763 unknown => {
1764 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
1765 extra_attrs.insert(key, val.into_owned());
1766 }
1767 #[cfg(not(feature = "extra-attrs"))]
1768 _ => {}
1769 }
1770 }
1771
1772 if !is_empty {
1774 let mut buf = Vec::new();
1775 loop {
1776 match reader.read_event_into(&mut buf)? {
1777 Event::Start(e) => {
1778 match e.local_name().as_ref() {
1779 b"bg" => {
1780 f_bg = Some(Box::new(CTEmpty::from_xml(reader, &e, false)?));
1781 #[cfg(feature = "extra-children")]
1782 {
1783 child_idx += 1;
1784 }
1785 }
1786 b"subSp" => {
1787 f_sub_sp =
1788 Some(Box::new(CTTLSubShapeId::from_xml(reader, &e, false)?));
1789 #[cfg(feature = "extra-children")]
1790 {
1791 child_idx += 1;
1792 }
1793 }
1794 b"oleChartEl" => {
1795 f_ole_chart_el = Some(Box::new(
1796 CTTLOleChartTargetElement::from_xml(reader, &e, false)?,
1797 ));
1798 #[cfg(feature = "extra-children")]
1799 {
1800 child_idx += 1;
1801 }
1802 }
1803 b"txEl" => {
1804 f_tx_el = Some(Box::new(CTTLTextTargetElement::from_xml(
1805 reader, &e, false,
1806 )?));
1807 #[cfg(feature = "extra-children")]
1808 {
1809 child_idx += 1;
1810 }
1811 }
1812 b"graphicEl" => {
1813 f_graphic_el = Some(Box::new(
1814 ooxml_dml::types::CTAnimationElementChoice::from_xml(
1815 reader, &e, false,
1816 )?,
1817 ));
1818 #[cfg(feature = "extra-children")]
1819 {
1820 child_idx += 1;
1821 }
1822 }
1823 #[cfg(feature = "extra-children")]
1824 _ => {
1825 let elem = RawXmlElement::from_reader(reader, &e)?;
1827 extra_children.push(PositionedNode::new(
1828 child_idx,
1829 RawXmlNode::Element(elem),
1830 ));
1831 child_idx += 1;
1832 }
1833 #[cfg(not(feature = "extra-children"))]
1834 _ => {
1835 skip_element(reader)?;
1837 }
1838 }
1839 }
1840 Event::Empty(e) => {
1841 match e.local_name().as_ref() {
1842 b"bg" => {
1843 f_bg = Some(Box::new(CTEmpty::from_xml(reader, &e, true)?));
1844 #[cfg(feature = "extra-children")]
1845 {
1846 child_idx += 1;
1847 }
1848 }
1849 b"subSp" => {
1850 f_sub_sp =
1851 Some(Box::new(CTTLSubShapeId::from_xml(reader, &e, true)?));
1852 #[cfg(feature = "extra-children")]
1853 {
1854 child_idx += 1;
1855 }
1856 }
1857 b"oleChartEl" => {
1858 f_ole_chart_el = Some(Box::new(
1859 CTTLOleChartTargetElement::from_xml(reader, &e, true)?,
1860 ));
1861 #[cfg(feature = "extra-children")]
1862 {
1863 child_idx += 1;
1864 }
1865 }
1866 b"txEl" => {
1867 f_tx_el = Some(Box::new(CTTLTextTargetElement::from_xml(
1868 reader, &e, true,
1869 )?));
1870 #[cfg(feature = "extra-children")]
1871 {
1872 child_idx += 1;
1873 }
1874 }
1875 b"graphicEl" => {
1876 f_graphic_el = Some(Box::new(
1877 ooxml_dml::types::CTAnimationElementChoice::from_xml(
1878 reader, &e, true,
1879 )?,
1880 ));
1881 #[cfg(feature = "extra-children")]
1882 {
1883 child_idx += 1;
1884 }
1885 }
1886 #[cfg(feature = "extra-children")]
1887 _ => {
1888 let elem = RawXmlElement::from_empty(&e);
1890 extra_children.push(PositionedNode::new(
1891 child_idx,
1892 RawXmlNode::Element(elem),
1893 ));
1894 child_idx += 1;
1895 }
1896 #[cfg(not(feature = "extra-children"))]
1897 _ => {}
1898 }
1899 }
1900 Event::End(_) => break,
1901 Event::Eof => break,
1902 _ => {}
1903 }
1904 buf.clear();
1905 }
1906 }
1907
1908 Ok(Self {
1909 spid: f_spid.ok_or_else(|| ParseError::MissingAttribute("spid".to_string()))?,
1910 bg: f_bg,
1911 sub_sp: f_sub_sp,
1912 ole_chart_el: f_ole_chart_el,
1913 tx_el: f_tx_el,
1914 graphic_el: f_graphic_el,
1915 #[cfg(feature = "extra-attrs")]
1916 extra_attrs,
1917 #[cfg(feature = "extra-children")]
1918 extra_children,
1919 })
1920 }
1921}
1922
1923impl FromXml for CTTLTimeTargetElement {
1924 fn from_xml<R: BufRead>(
1925 reader: &mut Reader<R>,
1926 start_tag: &BytesStart,
1927 is_empty: bool,
1928 ) -> Result<Self, ParseError> {
1929 let mut f_sld_tgt = None;
1930 let mut f_snd_tgt = None;
1931 let mut f_sp_tgt = None;
1932 let mut f_ink_tgt = None;
1933 #[cfg(feature = "extra-children")]
1934 let mut extra_children = Vec::new();
1935 #[cfg(feature = "extra-children")]
1936 let mut child_idx: usize = 0;
1937
1938 if !is_empty {
1940 let mut buf = Vec::new();
1941 loop {
1942 match reader.read_event_into(&mut buf)? {
1943 Event::Start(e) => {
1944 match e.local_name().as_ref() {
1945 b"sldTgt" => {
1946 f_sld_tgt = Some(Box::new(CTEmpty::from_xml(reader, &e, false)?));
1947 #[cfg(feature = "extra-children")]
1948 {
1949 child_idx += 1;
1950 }
1951 }
1952 b"sndTgt" => {
1953 f_snd_tgt = Some(Box::new(
1954 ooxml_dml::types::CTEmbeddedWAVAudioFile::from_xml(
1955 reader, &e, false,
1956 )?,
1957 ));
1958 #[cfg(feature = "extra-children")]
1959 {
1960 child_idx += 1;
1961 }
1962 }
1963 b"spTgt" => {
1964 f_sp_tgt = Some(Box::new(CTTLShapeTargetElement::from_xml(
1965 reader, &e, false,
1966 )?));
1967 #[cfg(feature = "extra-children")]
1968 {
1969 child_idx += 1;
1970 }
1971 }
1972 b"inkTgt" => {
1973 f_ink_tgt =
1974 Some(Box::new(CTTLSubShapeId::from_xml(reader, &e, false)?));
1975 #[cfg(feature = "extra-children")]
1976 {
1977 child_idx += 1;
1978 }
1979 }
1980 #[cfg(feature = "extra-children")]
1981 _ => {
1982 let elem = RawXmlElement::from_reader(reader, &e)?;
1984 extra_children.push(PositionedNode::new(
1985 child_idx,
1986 RawXmlNode::Element(elem),
1987 ));
1988 child_idx += 1;
1989 }
1990 #[cfg(not(feature = "extra-children"))]
1991 _ => {
1992 skip_element(reader)?;
1994 }
1995 }
1996 }
1997 Event::Empty(e) => {
1998 match e.local_name().as_ref() {
1999 b"sldTgt" => {
2000 f_sld_tgt = Some(Box::new(CTEmpty::from_xml(reader, &e, true)?));
2001 #[cfg(feature = "extra-children")]
2002 {
2003 child_idx += 1;
2004 }
2005 }
2006 b"sndTgt" => {
2007 f_snd_tgt = Some(Box::new(
2008 ooxml_dml::types::CTEmbeddedWAVAudioFile::from_xml(
2009 reader, &e, true,
2010 )?,
2011 ));
2012 #[cfg(feature = "extra-children")]
2013 {
2014 child_idx += 1;
2015 }
2016 }
2017 b"spTgt" => {
2018 f_sp_tgt = Some(Box::new(CTTLShapeTargetElement::from_xml(
2019 reader, &e, true,
2020 )?));
2021 #[cfg(feature = "extra-children")]
2022 {
2023 child_idx += 1;
2024 }
2025 }
2026 b"inkTgt" => {
2027 f_ink_tgt =
2028 Some(Box::new(CTTLSubShapeId::from_xml(reader, &e, true)?));
2029 #[cfg(feature = "extra-children")]
2030 {
2031 child_idx += 1;
2032 }
2033 }
2034 #[cfg(feature = "extra-children")]
2035 _ => {
2036 let elem = RawXmlElement::from_empty(&e);
2038 extra_children.push(PositionedNode::new(
2039 child_idx,
2040 RawXmlNode::Element(elem),
2041 ));
2042 child_idx += 1;
2043 }
2044 #[cfg(not(feature = "extra-children"))]
2045 _ => {}
2046 }
2047 }
2048 Event::End(_) => break,
2049 Event::Eof => break,
2050 _ => {}
2051 }
2052 buf.clear();
2053 }
2054 }
2055
2056 Ok(Self {
2057 sld_tgt: f_sld_tgt,
2058 snd_tgt: f_snd_tgt,
2059 sp_tgt: f_sp_tgt,
2060 ink_tgt: f_ink_tgt,
2061 #[cfg(feature = "extra-children")]
2062 extra_children,
2063 })
2064 }
2065}
2066
2067impl FromXml for CTTLTriggerTimeNodeID {
2068 fn from_xml<R: BufRead>(
2069 reader: &mut Reader<R>,
2070 start_tag: &BytesStart,
2071 is_empty: bool,
2072 ) -> Result<Self, ParseError> {
2073 let mut f_value: Option<STTLTimeNodeID> = None;
2074 #[cfg(feature = "extra-attrs")]
2075 let mut extra_attrs = std::collections::HashMap::new();
2076
2077 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
2079 let val = String::from_utf8_lossy(&attr.value);
2080 match attr.key.local_name().as_ref() {
2081 b"val" => {
2082 f_value = val.parse().ok();
2083 }
2084 #[cfg(feature = "extra-attrs")]
2085 unknown => {
2086 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
2087 extra_attrs.insert(key, val.into_owned());
2088 }
2089 #[cfg(not(feature = "extra-attrs"))]
2090 _ => {}
2091 }
2092 }
2093
2094 if !is_empty {
2095 let mut buf = Vec::new();
2096 loop {
2097 match reader.read_event_into(&mut buf)? {
2098 Event::End(_) => break,
2099 Event::Eof => break,
2100 _ => {}
2101 }
2102 buf.clear();
2103 }
2104 }
2105
2106 Ok(Self {
2107 value: f_value.ok_or_else(|| ParseError::MissingAttribute("val".to_string()))?,
2108 #[cfg(feature = "extra-attrs")]
2109 extra_attrs,
2110 })
2111 }
2112}
2113
2114impl FromXml for CTTLTriggerRuntimeNode {
2115 fn from_xml<R: BufRead>(
2116 reader: &mut Reader<R>,
2117 start_tag: &BytesStart,
2118 is_empty: bool,
2119 ) -> Result<Self, ParseError> {
2120 let mut f_value: Option<STTLTriggerRuntimeNode> = None;
2121 #[cfg(feature = "extra-attrs")]
2122 let mut extra_attrs = std::collections::HashMap::new();
2123
2124 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
2126 let val = String::from_utf8_lossy(&attr.value);
2127 match attr.key.local_name().as_ref() {
2128 b"val" => {
2129 f_value = val.parse().ok();
2130 }
2131 #[cfg(feature = "extra-attrs")]
2132 unknown => {
2133 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
2134 extra_attrs.insert(key, val.into_owned());
2135 }
2136 #[cfg(not(feature = "extra-attrs"))]
2137 _ => {}
2138 }
2139 }
2140
2141 if !is_empty {
2142 let mut buf = Vec::new();
2143 loop {
2144 match reader.read_event_into(&mut buf)? {
2145 Event::End(_) => break,
2146 Event::Eof => break,
2147 _ => {}
2148 }
2149 buf.clear();
2150 }
2151 }
2152
2153 Ok(Self {
2154 value: f_value.ok_or_else(|| ParseError::MissingAttribute("val".to_string()))?,
2155 #[cfg(feature = "extra-attrs")]
2156 extra_attrs,
2157 })
2158 }
2159}
2160
2161impl FromXml for CTTLTimeCondition {
2162 fn from_xml<R: BufRead>(
2163 reader: &mut Reader<R>,
2164 start_tag: &BytesStart,
2165 is_empty: bool,
2166 ) -> Result<Self, ParseError> {
2167 let mut f_evt = None;
2168 let mut f_delay = None;
2169 let mut f_tgt_el = None;
2170 let mut f_tn = None;
2171 let mut f_rtn = None;
2172 #[cfg(feature = "extra-attrs")]
2173 let mut extra_attrs = std::collections::HashMap::new();
2174 #[cfg(feature = "extra-children")]
2175 let mut extra_children = Vec::new();
2176 #[cfg(feature = "extra-children")]
2177 let mut child_idx: usize = 0;
2178
2179 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
2181 let val = String::from_utf8_lossy(&attr.value);
2182 match attr.key.local_name().as_ref() {
2183 b"evt" => {
2184 f_evt = val.parse().ok();
2185 }
2186 b"delay" => {
2187 f_delay = Some(val.into_owned());
2188 }
2189 #[cfg(feature = "extra-attrs")]
2190 unknown => {
2191 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
2192 extra_attrs.insert(key, val.into_owned());
2193 }
2194 #[cfg(not(feature = "extra-attrs"))]
2195 _ => {}
2196 }
2197 }
2198
2199 if !is_empty {
2201 let mut buf = Vec::new();
2202 loop {
2203 match reader.read_event_into(&mut buf)? {
2204 Event::Start(e) => {
2205 match e.local_name().as_ref() {
2206 b"tgtEl" => {
2207 f_tgt_el = Some(Box::new(CTTLTimeTargetElement::from_xml(
2208 reader, &e, false,
2209 )?));
2210 #[cfg(feature = "extra-children")]
2211 {
2212 child_idx += 1;
2213 }
2214 }
2215 b"tn" => {
2216 f_tn = Some(Box::new(CTTLTriggerTimeNodeID::from_xml(
2217 reader, &e, false,
2218 )?));
2219 #[cfg(feature = "extra-children")]
2220 {
2221 child_idx += 1;
2222 }
2223 }
2224 b"rtn" => {
2225 f_rtn = Some(Box::new(CTTLTriggerRuntimeNode::from_xml(
2226 reader, &e, false,
2227 )?));
2228 #[cfg(feature = "extra-children")]
2229 {
2230 child_idx += 1;
2231 }
2232 }
2233 #[cfg(feature = "extra-children")]
2234 _ => {
2235 let elem = RawXmlElement::from_reader(reader, &e)?;
2237 extra_children.push(PositionedNode::new(
2238 child_idx,
2239 RawXmlNode::Element(elem),
2240 ));
2241 child_idx += 1;
2242 }
2243 #[cfg(not(feature = "extra-children"))]
2244 _ => {
2245 skip_element(reader)?;
2247 }
2248 }
2249 }
2250 Event::Empty(e) => {
2251 match e.local_name().as_ref() {
2252 b"tgtEl" => {
2253 f_tgt_el = Some(Box::new(CTTLTimeTargetElement::from_xml(
2254 reader, &e, true,
2255 )?));
2256 #[cfg(feature = "extra-children")]
2257 {
2258 child_idx += 1;
2259 }
2260 }
2261 b"tn" => {
2262 f_tn = Some(Box::new(CTTLTriggerTimeNodeID::from_xml(
2263 reader, &e, true,
2264 )?));
2265 #[cfg(feature = "extra-children")]
2266 {
2267 child_idx += 1;
2268 }
2269 }
2270 b"rtn" => {
2271 f_rtn = Some(Box::new(CTTLTriggerRuntimeNode::from_xml(
2272 reader, &e, true,
2273 )?));
2274 #[cfg(feature = "extra-children")]
2275 {
2276 child_idx += 1;
2277 }
2278 }
2279 #[cfg(feature = "extra-children")]
2280 _ => {
2281 let elem = RawXmlElement::from_empty(&e);
2283 extra_children.push(PositionedNode::new(
2284 child_idx,
2285 RawXmlNode::Element(elem),
2286 ));
2287 child_idx += 1;
2288 }
2289 #[cfg(not(feature = "extra-children"))]
2290 _ => {}
2291 }
2292 }
2293 Event::End(_) => break,
2294 Event::Eof => break,
2295 _ => {}
2296 }
2297 buf.clear();
2298 }
2299 }
2300
2301 Ok(Self {
2302 evt: f_evt,
2303 delay: f_delay,
2304 tgt_el: f_tgt_el,
2305 tn: f_tn,
2306 rtn: f_rtn,
2307 #[cfg(feature = "extra-attrs")]
2308 extra_attrs,
2309 #[cfg(feature = "extra-children")]
2310 extra_children,
2311 })
2312 }
2313}
2314
2315impl FromXml for CTTLTimeConditionList {
2316 fn from_xml<R: BufRead>(
2317 reader: &mut Reader<R>,
2318 start_tag: &BytesStart,
2319 is_empty: bool,
2320 ) -> Result<Self, ParseError> {
2321 let mut f_cond = Vec::new();
2322 #[cfg(feature = "extra-children")]
2323 let mut extra_children = Vec::new();
2324 #[cfg(feature = "extra-children")]
2325 let mut child_idx: usize = 0;
2326
2327 if !is_empty {
2329 let mut buf = Vec::new();
2330 loop {
2331 match reader.read_event_into(&mut buf)? {
2332 Event::Start(e) => {
2333 match e.local_name().as_ref() {
2334 b"cond" => {
2335 f_cond.push(CTTLTimeCondition::from_xml(reader, &e, false)?);
2336 #[cfg(feature = "extra-children")]
2337 {
2338 child_idx += 1;
2339 }
2340 }
2341 #[cfg(feature = "extra-children")]
2342 _ => {
2343 let elem = RawXmlElement::from_reader(reader, &e)?;
2345 extra_children.push(PositionedNode::new(
2346 child_idx,
2347 RawXmlNode::Element(elem),
2348 ));
2349 child_idx += 1;
2350 }
2351 #[cfg(not(feature = "extra-children"))]
2352 _ => {
2353 skip_element(reader)?;
2355 }
2356 }
2357 }
2358 Event::Empty(e) => {
2359 match e.local_name().as_ref() {
2360 b"cond" => {
2361 f_cond.push(CTTLTimeCondition::from_xml(reader, &e, true)?);
2362 #[cfg(feature = "extra-children")]
2363 {
2364 child_idx += 1;
2365 }
2366 }
2367 #[cfg(feature = "extra-children")]
2368 _ => {
2369 let elem = RawXmlElement::from_empty(&e);
2371 extra_children.push(PositionedNode::new(
2372 child_idx,
2373 RawXmlNode::Element(elem),
2374 ));
2375 child_idx += 1;
2376 }
2377 #[cfg(not(feature = "extra-children"))]
2378 _ => {}
2379 }
2380 }
2381 Event::End(_) => break,
2382 Event::Eof => break,
2383 _ => {}
2384 }
2385 buf.clear();
2386 }
2387 }
2388
2389 Ok(Self {
2390 cond: f_cond,
2391 #[cfg(feature = "extra-children")]
2392 extra_children,
2393 })
2394 }
2395}
2396
2397impl FromXml for CTTimeNodeList {
2398 fn from_xml<R: BufRead>(
2399 reader: &mut Reader<R>,
2400 start_tag: &BytesStart,
2401 is_empty: bool,
2402 ) -> Result<Self, ParseError> {
2403 let mut f_par = Vec::new();
2404 let mut f_seq = Vec::new();
2405 let mut f_excl = Vec::new();
2406 let mut f_anim = Vec::new();
2407 let mut f_anim_clr = Vec::new();
2408 let mut f_anim_effect = Vec::new();
2409 let mut f_anim_motion = Vec::new();
2410 let mut f_anim_rot = Vec::new();
2411 let mut f_anim_scale = Vec::new();
2412 let mut f_cmd = Vec::new();
2413 let mut f_set = Vec::new();
2414 let mut f_audio = Vec::new();
2415 let mut f_video = Vec::new();
2416 #[cfg(feature = "extra-children")]
2417 let mut extra_children = Vec::new();
2418 #[cfg(feature = "extra-children")]
2419 let mut child_idx: usize = 0;
2420
2421 if !is_empty {
2423 let mut buf = Vec::new();
2424 loop {
2425 match reader.read_event_into(&mut buf)? {
2426 Event::Start(e) => {
2427 match e.local_name().as_ref() {
2428 b"par" => {
2429 f_par.push(Box::new(CTTLCommonTimeNodeData::from_xml(
2430 reader, &e, false,
2431 )?));
2432 #[cfg(feature = "extra-children")]
2433 {
2434 child_idx += 1;
2435 }
2436 }
2437 b"seq" => {
2438 f_seq.push(CTTLTimeNodeSequence::from_xml(reader, &e, false)?);
2439 #[cfg(feature = "extra-children")]
2440 {
2441 child_idx += 1;
2442 }
2443 }
2444 b"excl" => {
2445 f_excl.push(Box::new(CTTLCommonTimeNodeData::from_xml(
2446 reader, &e, false,
2447 )?));
2448 #[cfg(feature = "extra-children")]
2449 {
2450 child_idx += 1;
2451 }
2452 }
2453 b"anim" => {
2454 f_anim.push(CTTLAnimateBehavior::from_xml(reader, &e, false)?);
2455 #[cfg(feature = "extra-children")]
2456 {
2457 child_idx += 1;
2458 }
2459 }
2460 b"animClr" => {
2461 f_anim_clr
2462 .push(CTTLAnimateColorBehavior::from_xml(reader, &e, false)?);
2463 #[cfg(feature = "extra-children")]
2464 {
2465 child_idx += 1;
2466 }
2467 }
2468 b"animEffect" => {
2469 f_anim_effect
2470 .push(CTTLAnimateEffectBehavior::from_xml(reader, &e, false)?);
2471 #[cfg(feature = "extra-children")]
2472 {
2473 child_idx += 1;
2474 }
2475 }
2476 b"animMotion" => {
2477 f_anim_motion
2478 .push(CTTLAnimateMotionBehavior::from_xml(reader, &e, false)?);
2479 #[cfg(feature = "extra-children")]
2480 {
2481 child_idx += 1;
2482 }
2483 }
2484 b"animRot" => {
2485 f_anim_rot.push(CTTLAnimateRotationBehavior::from_xml(
2486 reader, &e, false,
2487 )?);
2488 #[cfg(feature = "extra-children")]
2489 {
2490 child_idx += 1;
2491 }
2492 }
2493 b"animScale" => {
2494 f_anim_scale
2495 .push(CTTLAnimateScaleBehavior::from_xml(reader, &e, false)?);
2496 #[cfg(feature = "extra-children")]
2497 {
2498 child_idx += 1;
2499 }
2500 }
2501 b"cmd" => {
2502 f_cmd.push(CTTLCommandBehavior::from_xml(reader, &e, false)?);
2503 #[cfg(feature = "extra-children")]
2504 {
2505 child_idx += 1;
2506 }
2507 }
2508 b"set" => {
2509 f_set.push(CTTLSetBehavior::from_xml(reader, &e, false)?);
2510 #[cfg(feature = "extra-children")]
2511 {
2512 child_idx += 1;
2513 }
2514 }
2515 b"audio" => {
2516 f_audio.push(CTTLMediaNodeAudio::from_xml(reader, &e, false)?);
2517 #[cfg(feature = "extra-children")]
2518 {
2519 child_idx += 1;
2520 }
2521 }
2522 b"video" => {
2523 f_video.push(CTTLMediaNodeVideo::from_xml(reader, &e, false)?);
2524 #[cfg(feature = "extra-children")]
2525 {
2526 child_idx += 1;
2527 }
2528 }
2529 #[cfg(feature = "extra-children")]
2530 _ => {
2531 let elem = RawXmlElement::from_reader(reader, &e)?;
2533 extra_children.push(PositionedNode::new(
2534 child_idx,
2535 RawXmlNode::Element(elem),
2536 ));
2537 child_idx += 1;
2538 }
2539 #[cfg(not(feature = "extra-children"))]
2540 _ => {
2541 skip_element(reader)?;
2543 }
2544 }
2545 }
2546 Event::Empty(e) => {
2547 match e.local_name().as_ref() {
2548 b"par" => {
2549 f_par.push(Box::new(CTTLCommonTimeNodeData::from_xml(
2550 reader, &e, true,
2551 )?));
2552 #[cfg(feature = "extra-children")]
2553 {
2554 child_idx += 1;
2555 }
2556 }
2557 b"seq" => {
2558 f_seq.push(CTTLTimeNodeSequence::from_xml(reader, &e, true)?);
2559 #[cfg(feature = "extra-children")]
2560 {
2561 child_idx += 1;
2562 }
2563 }
2564 b"excl" => {
2565 f_excl.push(Box::new(CTTLCommonTimeNodeData::from_xml(
2566 reader, &e, true,
2567 )?));
2568 #[cfg(feature = "extra-children")]
2569 {
2570 child_idx += 1;
2571 }
2572 }
2573 b"anim" => {
2574 f_anim.push(CTTLAnimateBehavior::from_xml(reader, &e, true)?);
2575 #[cfg(feature = "extra-children")]
2576 {
2577 child_idx += 1;
2578 }
2579 }
2580 b"animClr" => {
2581 f_anim_clr
2582 .push(CTTLAnimateColorBehavior::from_xml(reader, &e, true)?);
2583 #[cfg(feature = "extra-children")]
2584 {
2585 child_idx += 1;
2586 }
2587 }
2588 b"animEffect" => {
2589 f_anim_effect
2590 .push(CTTLAnimateEffectBehavior::from_xml(reader, &e, true)?);
2591 #[cfg(feature = "extra-children")]
2592 {
2593 child_idx += 1;
2594 }
2595 }
2596 b"animMotion" => {
2597 f_anim_motion
2598 .push(CTTLAnimateMotionBehavior::from_xml(reader, &e, true)?);
2599 #[cfg(feature = "extra-children")]
2600 {
2601 child_idx += 1;
2602 }
2603 }
2604 b"animRot" => {
2605 f_anim_rot
2606 .push(CTTLAnimateRotationBehavior::from_xml(reader, &e, true)?);
2607 #[cfg(feature = "extra-children")]
2608 {
2609 child_idx += 1;
2610 }
2611 }
2612 b"animScale" => {
2613 f_anim_scale
2614 .push(CTTLAnimateScaleBehavior::from_xml(reader, &e, true)?);
2615 #[cfg(feature = "extra-children")]
2616 {
2617 child_idx += 1;
2618 }
2619 }
2620 b"cmd" => {
2621 f_cmd.push(CTTLCommandBehavior::from_xml(reader, &e, true)?);
2622 #[cfg(feature = "extra-children")]
2623 {
2624 child_idx += 1;
2625 }
2626 }
2627 b"set" => {
2628 f_set.push(CTTLSetBehavior::from_xml(reader, &e, true)?);
2629 #[cfg(feature = "extra-children")]
2630 {
2631 child_idx += 1;
2632 }
2633 }
2634 b"audio" => {
2635 f_audio.push(CTTLMediaNodeAudio::from_xml(reader, &e, true)?);
2636 #[cfg(feature = "extra-children")]
2637 {
2638 child_idx += 1;
2639 }
2640 }
2641 b"video" => {
2642 f_video.push(CTTLMediaNodeVideo::from_xml(reader, &e, true)?);
2643 #[cfg(feature = "extra-children")]
2644 {
2645 child_idx += 1;
2646 }
2647 }
2648 #[cfg(feature = "extra-children")]
2649 _ => {
2650 let elem = RawXmlElement::from_empty(&e);
2652 extra_children.push(PositionedNode::new(
2653 child_idx,
2654 RawXmlNode::Element(elem),
2655 ));
2656 child_idx += 1;
2657 }
2658 #[cfg(not(feature = "extra-children"))]
2659 _ => {}
2660 }
2661 }
2662 Event::End(_) => break,
2663 Event::Eof => break,
2664 _ => {}
2665 }
2666 buf.clear();
2667 }
2668 }
2669
2670 Ok(Self {
2671 par: f_par,
2672 seq: f_seq,
2673 excl: f_excl,
2674 anim: f_anim,
2675 anim_clr: f_anim_clr,
2676 anim_effect: f_anim_effect,
2677 anim_motion: f_anim_motion,
2678 anim_rot: f_anim_rot,
2679 anim_scale: f_anim_scale,
2680 cmd: f_cmd,
2681 set: f_set,
2682 audio: f_audio,
2683 video: f_video,
2684 #[cfg(feature = "extra-children")]
2685 extra_children,
2686 })
2687 }
2688}
2689
2690impl FromXml for CTTLCommonTimeNodeData {
2691 fn from_xml<R: BufRead>(
2692 reader: &mut Reader<R>,
2693 start_tag: &BytesStart,
2694 is_empty: bool,
2695 ) -> Result<Self, ParseError> {
2696 let mut f_id = None;
2697 let mut f_preset_i_d = None;
2698 let mut f_preset_class = None;
2699 let mut f_preset_subtype = None;
2700 let mut f_dur = None;
2701 let mut f_repeat_count = None;
2702 let mut f_repeat_dur = None;
2703 let mut f_spd = None;
2704 let mut f_accel = None;
2705 let mut f_decel = None;
2706 let mut f_auto_rev = None;
2707 let mut f_restart = None;
2708 let mut f_fill = None;
2709 let mut f_sync_behavior = None;
2710 let mut f_tm_filter = None;
2711 let mut f_evt_filter = None;
2712 let mut f_display = None;
2713 let mut f_master_rel = None;
2714 let mut f_bld_lvl = None;
2715 let mut f_grp_id = None;
2716 let mut f_after_effect = None;
2717 let mut f_node_type = None;
2718 let mut f_node_ph = None;
2719 let mut f_st_cond_lst = None;
2720 let mut f_end_cond_lst = None;
2721 let mut f_end_sync = None;
2722 let mut f_iterate = None;
2723 let mut f_child_tn_lst = None;
2724 let mut f_sub_tn_lst = None;
2725 #[cfg(feature = "extra-attrs")]
2726 let mut extra_attrs = std::collections::HashMap::new();
2727 #[cfg(feature = "extra-children")]
2728 let mut extra_children = Vec::new();
2729 #[cfg(feature = "extra-children")]
2730 let mut child_idx: usize = 0;
2731
2732 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
2734 let val = String::from_utf8_lossy(&attr.value);
2735 match attr.key.local_name().as_ref() {
2736 b"id" => {
2737 f_id = val.parse().ok();
2738 }
2739 b"presetID" => {
2740 f_preset_i_d = val.parse().ok();
2741 }
2742 b"presetClass" => {
2743 f_preset_class = val.parse().ok();
2744 }
2745 b"presetSubtype" => {
2746 f_preset_subtype = val.parse().ok();
2747 }
2748 b"dur" => {
2749 f_dur = Some(val.into_owned());
2750 }
2751 b"repeatCount" => {
2752 f_repeat_count = Some(val.into_owned());
2753 }
2754 b"repeatDur" => {
2755 f_repeat_dur = Some(val.into_owned());
2756 }
2757 b"spd" => {
2758 f_spd = val.parse().ok();
2759 }
2760 b"accel" => {
2761 f_accel = val.parse().ok();
2762 }
2763 b"decel" => {
2764 f_decel = val.parse().ok();
2765 }
2766 b"autoRev" => {
2767 f_auto_rev = Some(val == "true" || val == "1");
2768 }
2769 b"restart" => {
2770 f_restart = val.parse().ok();
2771 }
2772 b"fill" => {
2773 f_fill = val.parse().ok();
2774 }
2775 b"syncBehavior" => {
2776 f_sync_behavior = val.parse().ok();
2777 }
2778 b"tmFilter" => {
2779 f_tm_filter = Some(val.into_owned());
2780 }
2781 b"evtFilter" => {
2782 f_evt_filter = Some(val.into_owned());
2783 }
2784 b"display" => {
2785 f_display = Some(val == "true" || val == "1");
2786 }
2787 b"masterRel" => {
2788 f_master_rel = val.parse().ok();
2789 }
2790 b"bldLvl" => {
2791 f_bld_lvl = val.parse().ok();
2792 }
2793 b"grpId" => {
2794 f_grp_id = val.parse().ok();
2795 }
2796 b"afterEffect" => {
2797 f_after_effect = Some(val == "true" || val == "1");
2798 }
2799 b"nodeType" => {
2800 f_node_type = val.parse().ok();
2801 }
2802 b"nodePh" => {
2803 f_node_ph = Some(val == "true" || val == "1");
2804 }
2805 #[cfg(feature = "extra-attrs")]
2806 unknown => {
2807 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
2808 extra_attrs.insert(key, val.into_owned());
2809 }
2810 #[cfg(not(feature = "extra-attrs"))]
2811 _ => {}
2812 }
2813 }
2814
2815 if !is_empty {
2817 let mut buf = Vec::new();
2818 loop {
2819 match reader.read_event_into(&mut buf)? {
2820 Event::Start(e) => {
2821 match e.local_name().as_ref() {
2822 b"stCondLst" => {
2823 f_st_cond_lst = Some(Box::new(CTTLTimeConditionList::from_xml(
2824 reader, &e, false,
2825 )?));
2826 #[cfg(feature = "extra-children")]
2827 {
2828 child_idx += 1;
2829 }
2830 }
2831 b"endCondLst" => {
2832 f_end_cond_lst = Some(Box::new(CTTLTimeConditionList::from_xml(
2833 reader, &e, false,
2834 )?));
2835 #[cfg(feature = "extra-children")]
2836 {
2837 child_idx += 1;
2838 }
2839 }
2840 b"endSync" => {
2841 f_end_sync =
2842 Some(Box::new(CTTLTimeCondition::from_xml(reader, &e, false)?));
2843 #[cfg(feature = "extra-children")]
2844 {
2845 child_idx += 1;
2846 }
2847 }
2848 b"iterate" => {
2849 f_iterate =
2850 Some(Box::new(CTTLIterateData::from_xml(reader, &e, false)?));
2851 #[cfg(feature = "extra-children")]
2852 {
2853 child_idx += 1;
2854 }
2855 }
2856 b"childTnLst" => {
2857 f_child_tn_lst =
2858 Some(Box::new(CTTimeNodeList::from_xml(reader, &e, false)?));
2859 #[cfg(feature = "extra-children")]
2860 {
2861 child_idx += 1;
2862 }
2863 }
2864 b"subTnLst" => {
2865 f_sub_tn_lst =
2866 Some(Box::new(CTTimeNodeList::from_xml(reader, &e, false)?));
2867 #[cfg(feature = "extra-children")]
2868 {
2869 child_idx += 1;
2870 }
2871 }
2872 #[cfg(feature = "extra-children")]
2873 _ => {
2874 let elem = RawXmlElement::from_reader(reader, &e)?;
2876 extra_children.push(PositionedNode::new(
2877 child_idx,
2878 RawXmlNode::Element(elem),
2879 ));
2880 child_idx += 1;
2881 }
2882 #[cfg(not(feature = "extra-children"))]
2883 _ => {
2884 skip_element(reader)?;
2886 }
2887 }
2888 }
2889 Event::Empty(e) => {
2890 match e.local_name().as_ref() {
2891 b"stCondLst" => {
2892 f_st_cond_lst = Some(Box::new(CTTLTimeConditionList::from_xml(
2893 reader, &e, true,
2894 )?));
2895 #[cfg(feature = "extra-children")]
2896 {
2897 child_idx += 1;
2898 }
2899 }
2900 b"endCondLst" => {
2901 f_end_cond_lst = Some(Box::new(CTTLTimeConditionList::from_xml(
2902 reader, &e, true,
2903 )?));
2904 #[cfg(feature = "extra-children")]
2905 {
2906 child_idx += 1;
2907 }
2908 }
2909 b"endSync" => {
2910 f_end_sync =
2911 Some(Box::new(CTTLTimeCondition::from_xml(reader, &e, true)?));
2912 #[cfg(feature = "extra-children")]
2913 {
2914 child_idx += 1;
2915 }
2916 }
2917 b"iterate" => {
2918 f_iterate =
2919 Some(Box::new(CTTLIterateData::from_xml(reader, &e, true)?));
2920 #[cfg(feature = "extra-children")]
2921 {
2922 child_idx += 1;
2923 }
2924 }
2925 b"childTnLst" => {
2926 f_child_tn_lst =
2927 Some(Box::new(CTTimeNodeList::from_xml(reader, &e, true)?));
2928 #[cfg(feature = "extra-children")]
2929 {
2930 child_idx += 1;
2931 }
2932 }
2933 b"subTnLst" => {
2934 f_sub_tn_lst =
2935 Some(Box::new(CTTimeNodeList::from_xml(reader, &e, true)?));
2936 #[cfg(feature = "extra-children")]
2937 {
2938 child_idx += 1;
2939 }
2940 }
2941 #[cfg(feature = "extra-children")]
2942 _ => {
2943 let elem = RawXmlElement::from_empty(&e);
2945 extra_children.push(PositionedNode::new(
2946 child_idx,
2947 RawXmlNode::Element(elem),
2948 ));
2949 child_idx += 1;
2950 }
2951 #[cfg(not(feature = "extra-children"))]
2952 _ => {}
2953 }
2954 }
2955 Event::End(_) => break,
2956 Event::Eof => break,
2957 _ => {}
2958 }
2959 buf.clear();
2960 }
2961 }
2962
2963 Ok(Self {
2964 id: f_id,
2965 preset_i_d: f_preset_i_d,
2966 preset_class: f_preset_class,
2967 preset_subtype: f_preset_subtype,
2968 dur: f_dur,
2969 repeat_count: f_repeat_count,
2970 repeat_dur: f_repeat_dur,
2971 spd: f_spd,
2972 accel: f_accel,
2973 decel: f_decel,
2974 auto_rev: f_auto_rev,
2975 restart: f_restart,
2976 fill: f_fill,
2977 sync_behavior: f_sync_behavior,
2978 tm_filter: f_tm_filter,
2979 evt_filter: f_evt_filter,
2980 display: f_display,
2981 master_rel: f_master_rel,
2982 bld_lvl: f_bld_lvl,
2983 grp_id: f_grp_id,
2984 after_effect: f_after_effect,
2985 node_type: f_node_type,
2986 node_ph: f_node_ph,
2987 st_cond_lst: f_st_cond_lst,
2988 end_cond_lst: f_end_cond_lst,
2989 end_sync: f_end_sync,
2990 iterate: f_iterate,
2991 child_tn_lst: f_child_tn_lst,
2992 sub_tn_lst: f_sub_tn_lst,
2993 #[cfg(feature = "extra-attrs")]
2994 extra_attrs,
2995 #[cfg(feature = "extra-children")]
2996 extra_children,
2997 })
2998 }
2999}
3000
3001impl FromXml for CTTLTimeNodeSequence {
3002 fn from_xml<R: BufRead>(
3003 reader: &mut Reader<R>,
3004 start_tag: &BytesStart,
3005 is_empty: bool,
3006 ) -> Result<Self, ParseError> {
3007 let mut f_concurrent = None;
3008 let mut f_prev_ac = None;
3009 let mut f_next_ac = None;
3010 let mut f_c_tn: Option<Box<CTTLCommonTimeNodeData>> = None;
3011 let mut f_prev_cond_lst = None;
3012 let mut f_next_cond_lst = None;
3013 #[cfg(feature = "extra-attrs")]
3014 let mut extra_attrs = std::collections::HashMap::new();
3015 #[cfg(feature = "extra-children")]
3016 let mut extra_children = Vec::new();
3017 #[cfg(feature = "extra-children")]
3018 let mut child_idx: usize = 0;
3019
3020 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
3022 let val = String::from_utf8_lossy(&attr.value);
3023 match attr.key.local_name().as_ref() {
3024 b"concurrent" => {
3025 f_concurrent = Some(val == "true" || val == "1");
3026 }
3027 b"prevAc" => {
3028 f_prev_ac = val.parse().ok();
3029 }
3030 b"nextAc" => {
3031 f_next_ac = val.parse().ok();
3032 }
3033 #[cfg(feature = "extra-attrs")]
3034 unknown => {
3035 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
3036 extra_attrs.insert(key, val.into_owned());
3037 }
3038 #[cfg(not(feature = "extra-attrs"))]
3039 _ => {}
3040 }
3041 }
3042
3043 if !is_empty {
3045 let mut buf = Vec::new();
3046 loop {
3047 match reader.read_event_into(&mut buf)? {
3048 Event::Start(e) => {
3049 match e.local_name().as_ref() {
3050 b"cTn" => {
3051 f_c_tn = Some(Box::new(CTTLCommonTimeNodeData::from_xml(
3052 reader, &e, false,
3053 )?));
3054 #[cfg(feature = "extra-children")]
3055 {
3056 child_idx += 1;
3057 }
3058 }
3059 b"prevCondLst" => {
3060 f_prev_cond_lst = Some(Box::new(CTTLTimeConditionList::from_xml(
3061 reader, &e, false,
3062 )?));
3063 #[cfg(feature = "extra-children")]
3064 {
3065 child_idx += 1;
3066 }
3067 }
3068 b"nextCondLst" => {
3069 f_next_cond_lst = Some(Box::new(CTTLTimeConditionList::from_xml(
3070 reader, &e, false,
3071 )?));
3072 #[cfg(feature = "extra-children")]
3073 {
3074 child_idx += 1;
3075 }
3076 }
3077 #[cfg(feature = "extra-children")]
3078 _ => {
3079 let elem = RawXmlElement::from_reader(reader, &e)?;
3081 extra_children.push(PositionedNode::new(
3082 child_idx,
3083 RawXmlNode::Element(elem),
3084 ));
3085 child_idx += 1;
3086 }
3087 #[cfg(not(feature = "extra-children"))]
3088 _ => {
3089 skip_element(reader)?;
3091 }
3092 }
3093 }
3094 Event::Empty(e) => {
3095 match e.local_name().as_ref() {
3096 b"cTn" => {
3097 f_c_tn = Some(Box::new(CTTLCommonTimeNodeData::from_xml(
3098 reader, &e, true,
3099 )?));
3100 #[cfg(feature = "extra-children")]
3101 {
3102 child_idx += 1;
3103 }
3104 }
3105 b"prevCondLst" => {
3106 f_prev_cond_lst = Some(Box::new(CTTLTimeConditionList::from_xml(
3107 reader, &e, true,
3108 )?));
3109 #[cfg(feature = "extra-children")]
3110 {
3111 child_idx += 1;
3112 }
3113 }
3114 b"nextCondLst" => {
3115 f_next_cond_lst = Some(Box::new(CTTLTimeConditionList::from_xml(
3116 reader, &e, true,
3117 )?));
3118 #[cfg(feature = "extra-children")]
3119 {
3120 child_idx += 1;
3121 }
3122 }
3123 #[cfg(feature = "extra-children")]
3124 _ => {
3125 let elem = RawXmlElement::from_empty(&e);
3127 extra_children.push(PositionedNode::new(
3128 child_idx,
3129 RawXmlNode::Element(elem),
3130 ));
3131 child_idx += 1;
3132 }
3133 #[cfg(not(feature = "extra-children"))]
3134 _ => {}
3135 }
3136 }
3137 Event::End(_) => break,
3138 Event::Eof => break,
3139 _ => {}
3140 }
3141 buf.clear();
3142 }
3143 }
3144
3145 Ok(Self {
3146 concurrent: f_concurrent,
3147 prev_ac: f_prev_ac,
3148 next_ac: f_next_ac,
3149 c_tn: f_c_tn.ok_or_else(|| ParseError::MissingAttribute("cTn".to_string()))?,
3150 prev_cond_lst: f_prev_cond_lst,
3151 next_cond_lst: f_next_cond_lst,
3152 #[cfg(feature = "extra-attrs")]
3153 extra_attrs,
3154 #[cfg(feature = "extra-children")]
3155 extra_children,
3156 })
3157 }
3158}
3159
3160impl FromXml for CTTLBehaviorAttributeNameList {
3161 fn from_xml<R: BufRead>(
3162 reader: &mut Reader<R>,
3163 start_tag: &BytesStart,
3164 is_empty: bool,
3165 ) -> Result<Self, ParseError> {
3166 let mut f_attr_name = Vec::new();
3167 #[cfg(feature = "extra-children")]
3168 let mut extra_children = Vec::new();
3169 #[cfg(feature = "extra-children")]
3170 let mut child_idx: usize = 0;
3171
3172 if !is_empty {
3174 let mut buf = Vec::new();
3175 loop {
3176 match reader.read_event_into(&mut buf)? {
3177 Event::Start(e) => {
3178 match e.local_name().as_ref() {
3179 b"attrName" => {
3180 f_attr_name.push(read_text_content(reader)?);
3181 #[cfg(feature = "extra-children")]
3182 {
3183 child_idx += 1;
3184 }
3185 }
3186 #[cfg(feature = "extra-children")]
3187 _ => {
3188 let elem = RawXmlElement::from_reader(reader, &e)?;
3190 extra_children.push(PositionedNode::new(
3191 child_idx,
3192 RawXmlNode::Element(elem),
3193 ));
3194 child_idx += 1;
3195 }
3196 #[cfg(not(feature = "extra-children"))]
3197 _ => {
3198 skip_element(reader)?;
3200 }
3201 }
3202 }
3203 Event::Empty(e) => {
3204 match e.local_name().as_ref() {
3205 b"attrName" => {
3206 f_attr_name.push(String::new());
3207 #[cfg(feature = "extra-children")]
3208 {
3209 child_idx += 1;
3210 }
3211 }
3212 #[cfg(feature = "extra-children")]
3213 _ => {
3214 let elem = RawXmlElement::from_empty(&e);
3216 extra_children.push(PositionedNode::new(
3217 child_idx,
3218 RawXmlNode::Element(elem),
3219 ));
3220 child_idx += 1;
3221 }
3222 #[cfg(not(feature = "extra-children"))]
3223 _ => {}
3224 }
3225 }
3226 Event::End(_) => break,
3227 Event::Eof => break,
3228 _ => {}
3229 }
3230 buf.clear();
3231 }
3232 }
3233
3234 Ok(Self {
3235 attr_name: f_attr_name,
3236 #[cfg(feature = "extra-children")]
3237 extra_children,
3238 })
3239 }
3240}
3241
3242impl FromXml for CTTLCommonBehaviorData {
3243 fn from_xml<R: BufRead>(
3244 reader: &mut Reader<R>,
3245 start_tag: &BytesStart,
3246 is_empty: bool,
3247 ) -> Result<Self, ParseError> {
3248 let mut f_additive = None;
3249 let mut f_accumulate = None;
3250 let mut f_xfrm_type = None;
3251 let mut f_from = None;
3252 let mut f_to = None;
3253 let mut f_by = None;
3254 let mut f_rctx = None;
3255 let mut f_override = None;
3256 let mut f_c_tn: Option<Box<CTTLCommonTimeNodeData>> = None;
3257 let mut f_tgt_el: Option<Box<CTTLTimeTargetElement>> = None;
3258 let mut f_attr_name_lst = None;
3259 #[cfg(feature = "extra-attrs")]
3260 let mut extra_attrs = std::collections::HashMap::new();
3261 #[cfg(feature = "extra-children")]
3262 let mut extra_children = Vec::new();
3263 #[cfg(feature = "extra-children")]
3264 let mut child_idx: usize = 0;
3265
3266 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
3268 let val = String::from_utf8_lossy(&attr.value);
3269 match attr.key.local_name().as_ref() {
3270 b"additive" => {
3271 f_additive = val.parse().ok();
3272 }
3273 b"accumulate" => {
3274 f_accumulate = val.parse().ok();
3275 }
3276 b"xfrmType" => {
3277 f_xfrm_type = val.parse().ok();
3278 }
3279 b"from" => {
3280 f_from = Some(val.into_owned());
3281 }
3282 b"to" => {
3283 f_to = Some(val.into_owned());
3284 }
3285 b"by" => {
3286 f_by = Some(val.into_owned());
3287 }
3288 b"rctx" => {
3289 f_rctx = Some(val.into_owned());
3290 }
3291 b"override" => {
3292 f_override = val.parse().ok();
3293 }
3294 #[cfg(feature = "extra-attrs")]
3295 unknown => {
3296 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
3297 extra_attrs.insert(key, val.into_owned());
3298 }
3299 #[cfg(not(feature = "extra-attrs"))]
3300 _ => {}
3301 }
3302 }
3303
3304 if !is_empty {
3306 let mut buf = Vec::new();
3307 loop {
3308 match reader.read_event_into(&mut buf)? {
3309 Event::Start(e) => {
3310 match e.local_name().as_ref() {
3311 b"cTn" => {
3312 f_c_tn = Some(Box::new(CTTLCommonTimeNodeData::from_xml(
3313 reader, &e, false,
3314 )?));
3315 #[cfg(feature = "extra-children")]
3316 {
3317 child_idx += 1;
3318 }
3319 }
3320 b"tgtEl" => {
3321 f_tgt_el = Some(Box::new(CTTLTimeTargetElement::from_xml(
3322 reader, &e, false,
3323 )?));
3324 #[cfg(feature = "extra-children")]
3325 {
3326 child_idx += 1;
3327 }
3328 }
3329 b"attrNameLst" => {
3330 f_attr_name_lst = Some(Box::new(
3331 CTTLBehaviorAttributeNameList::from_xml(reader, &e, false)?,
3332 ));
3333 #[cfg(feature = "extra-children")]
3334 {
3335 child_idx += 1;
3336 }
3337 }
3338 #[cfg(feature = "extra-children")]
3339 _ => {
3340 let elem = RawXmlElement::from_reader(reader, &e)?;
3342 extra_children.push(PositionedNode::new(
3343 child_idx,
3344 RawXmlNode::Element(elem),
3345 ));
3346 child_idx += 1;
3347 }
3348 #[cfg(not(feature = "extra-children"))]
3349 _ => {
3350 skip_element(reader)?;
3352 }
3353 }
3354 }
3355 Event::Empty(e) => {
3356 match e.local_name().as_ref() {
3357 b"cTn" => {
3358 f_c_tn = Some(Box::new(CTTLCommonTimeNodeData::from_xml(
3359 reader, &e, true,
3360 )?));
3361 #[cfg(feature = "extra-children")]
3362 {
3363 child_idx += 1;
3364 }
3365 }
3366 b"tgtEl" => {
3367 f_tgt_el = Some(Box::new(CTTLTimeTargetElement::from_xml(
3368 reader, &e, true,
3369 )?));
3370 #[cfg(feature = "extra-children")]
3371 {
3372 child_idx += 1;
3373 }
3374 }
3375 b"attrNameLst" => {
3376 f_attr_name_lst = Some(Box::new(
3377 CTTLBehaviorAttributeNameList::from_xml(reader, &e, true)?,
3378 ));
3379 #[cfg(feature = "extra-children")]
3380 {
3381 child_idx += 1;
3382 }
3383 }
3384 #[cfg(feature = "extra-children")]
3385 _ => {
3386 let elem = RawXmlElement::from_empty(&e);
3388 extra_children.push(PositionedNode::new(
3389 child_idx,
3390 RawXmlNode::Element(elem),
3391 ));
3392 child_idx += 1;
3393 }
3394 #[cfg(not(feature = "extra-children"))]
3395 _ => {}
3396 }
3397 }
3398 Event::End(_) => break,
3399 Event::Eof => break,
3400 _ => {}
3401 }
3402 buf.clear();
3403 }
3404 }
3405
3406 Ok(Self {
3407 additive: f_additive,
3408 accumulate: f_accumulate,
3409 xfrm_type: f_xfrm_type,
3410 from: f_from,
3411 to: f_to,
3412 by: f_by,
3413 rctx: f_rctx,
3414 r#override: f_override,
3415 c_tn: f_c_tn.ok_or_else(|| ParseError::MissingAttribute("cTn".to_string()))?,
3416 tgt_el: f_tgt_el.ok_or_else(|| ParseError::MissingAttribute("tgtEl".to_string()))?,
3417 attr_name_lst: f_attr_name_lst,
3418 #[cfg(feature = "extra-attrs")]
3419 extra_attrs,
3420 #[cfg(feature = "extra-children")]
3421 extra_children,
3422 })
3423 }
3424}
3425
3426impl FromXml for CTTLAnimVariantBooleanVal {
3427 fn from_xml<R: BufRead>(
3428 reader: &mut Reader<R>,
3429 start_tag: &BytesStart,
3430 is_empty: bool,
3431 ) -> Result<Self, ParseError> {
3432 let mut f_value: Option<bool> = None;
3433 #[cfg(feature = "extra-attrs")]
3434 let mut extra_attrs = std::collections::HashMap::new();
3435
3436 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
3438 let val = String::from_utf8_lossy(&attr.value);
3439 match attr.key.local_name().as_ref() {
3440 b"val" => {
3441 f_value = Some(val == "true" || val == "1");
3442 }
3443 #[cfg(feature = "extra-attrs")]
3444 unknown => {
3445 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
3446 extra_attrs.insert(key, val.into_owned());
3447 }
3448 #[cfg(not(feature = "extra-attrs"))]
3449 _ => {}
3450 }
3451 }
3452
3453 if !is_empty {
3454 let mut buf = Vec::new();
3455 loop {
3456 match reader.read_event_into(&mut buf)? {
3457 Event::End(_) => break,
3458 Event::Eof => break,
3459 _ => {}
3460 }
3461 buf.clear();
3462 }
3463 }
3464
3465 Ok(Self {
3466 value: f_value.ok_or_else(|| ParseError::MissingAttribute("val".to_string()))?,
3467 #[cfg(feature = "extra-attrs")]
3468 extra_attrs,
3469 })
3470 }
3471}
3472
3473impl FromXml for CTTLAnimVariantIntegerVal {
3474 fn from_xml<R: BufRead>(
3475 reader: &mut Reader<R>,
3476 start_tag: &BytesStart,
3477 is_empty: bool,
3478 ) -> Result<Self, ParseError> {
3479 let mut f_value: Option<i32> = None;
3480 #[cfg(feature = "extra-attrs")]
3481 let mut extra_attrs = std::collections::HashMap::new();
3482
3483 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
3485 let val = String::from_utf8_lossy(&attr.value);
3486 match attr.key.local_name().as_ref() {
3487 b"val" => {
3488 f_value = val.parse().ok();
3489 }
3490 #[cfg(feature = "extra-attrs")]
3491 unknown => {
3492 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
3493 extra_attrs.insert(key, val.into_owned());
3494 }
3495 #[cfg(not(feature = "extra-attrs"))]
3496 _ => {}
3497 }
3498 }
3499
3500 if !is_empty {
3501 let mut buf = Vec::new();
3502 loop {
3503 match reader.read_event_into(&mut buf)? {
3504 Event::End(_) => break,
3505 Event::Eof => break,
3506 _ => {}
3507 }
3508 buf.clear();
3509 }
3510 }
3511
3512 Ok(Self {
3513 value: f_value.ok_or_else(|| ParseError::MissingAttribute("val".to_string()))?,
3514 #[cfg(feature = "extra-attrs")]
3515 extra_attrs,
3516 })
3517 }
3518}
3519
3520impl FromXml for CTTLAnimVariantFloatVal {
3521 fn from_xml<R: BufRead>(
3522 reader: &mut Reader<R>,
3523 start_tag: &BytesStart,
3524 is_empty: bool,
3525 ) -> Result<Self, ParseError> {
3526 let mut f_value: Option<f32> = None;
3527 #[cfg(feature = "extra-attrs")]
3528 let mut extra_attrs = std::collections::HashMap::new();
3529
3530 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
3532 let val = String::from_utf8_lossy(&attr.value);
3533 match attr.key.local_name().as_ref() {
3534 b"val" => {
3535 f_value = val.parse().ok();
3536 }
3537 #[cfg(feature = "extra-attrs")]
3538 unknown => {
3539 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
3540 extra_attrs.insert(key, val.into_owned());
3541 }
3542 #[cfg(not(feature = "extra-attrs"))]
3543 _ => {}
3544 }
3545 }
3546
3547 if !is_empty {
3548 let mut buf = Vec::new();
3549 loop {
3550 match reader.read_event_into(&mut buf)? {
3551 Event::End(_) => break,
3552 Event::Eof => break,
3553 _ => {}
3554 }
3555 buf.clear();
3556 }
3557 }
3558
3559 Ok(Self {
3560 value: f_value.ok_or_else(|| ParseError::MissingAttribute("val".to_string()))?,
3561 #[cfg(feature = "extra-attrs")]
3562 extra_attrs,
3563 })
3564 }
3565}
3566
3567impl FromXml for CTTLAnimVariantStringVal {
3568 fn from_xml<R: BufRead>(
3569 reader: &mut Reader<R>,
3570 start_tag: &BytesStart,
3571 is_empty: bool,
3572 ) -> Result<Self, ParseError> {
3573 let mut f_value: Option<String> = None;
3574 #[cfg(feature = "extra-attrs")]
3575 let mut extra_attrs = std::collections::HashMap::new();
3576
3577 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
3579 let val = String::from_utf8_lossy(&attr.value);
3580 match attr.key.local_name().as_ref() {
3581 b"val" => {
3582 f_value = Some(val.into_owned());
3583 }
3584 #[cfg(feature = "extra-attrs")]
3585 unknown => {
3586 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
3587 extra_attrs.insert(key, val.into_owned());
3588 }
3589 #[cfg(not(feature = "extra-attrs"))]
3590 _ => {}
3591 }
3592 }
3593
3594 if !is_empty {
3595 let mut buf = Vec::new();
3596 loop {
3597 match reader.read_event_into(&mut buf)? {
3598 Event::End(_) => break,
3599 Event::Eof => break,
3600 _ => {}
3601 }
3602 buf.clear();
3603 }
3604 }
3605
3606 Ok(Self {
3607 value: f_value.ok_or_else(|| ParseError::MissingAttribute("val".to_string()))?,
3608 #[cfg(feature = "extra-attrs")]
3609 extra_attrs,
3610 })
3611 }
3612}
3613
3614impl FromXml for CTTLAnimVariant {
3615 fn from_xml<R: BufRead>(
3616 reader: &mut Reader<R>,
3617 start_tag: &BytesStart,
3618 is_empty: bool,
3619 ) -> Result<Self, ParseError> {
3620 let mut f_bool_val = None;
3621 let mut f_int_val = None;
3622 let mut f_flt_val = None;
3623 let mut f_str_val = None;
3624 let mut f_clr_val = None;
3625 #[cfg(feature = "extra-children")]
3626 let mut extra_children = Vec::new();
3627 #[cfg(feature = "extra-children")]
3628 let mut child_idx: usize = 0;
3629
3630 if !is_empty {
3632 let mut buf = Vec::new();
3633 loop {
3634 match reader.read_event_into(&mut buf)? {
3635 Event::Start(e) => {
3636 match e.local_name().as_ref() {
3637 b"boolVal" => {
3638 f_bool_val = Some(Box::new(CTTLAnimVariantBooleanVal::from_xml(
3639 reader, &e, false,
3640 )?));
3641 #[cfg(feature = "extra-children")]
3642 {
3643 child_idx += 1;
3644 }
3645 }
3646 b"intVal" => {
3647 f_int_val = Some(Box::new(CTTLAnimVariantIntegerVal::from_xml(
3648 reader, &e, false,
3649 )?));
3650 #[cfg(feature = "extra-children")]
3651 {
3652 child_idx += 1;
3653 }
3654 }
3655 b"fltVal" => {
3656 f_flt_val = Some(Box::new(CTTLAnimVariantFloatVal::from_xml(
3657 reader, &e, false,
3658 )?));
3659 #[cfg(feature = "extra-children")]
3660 {
3661 child_idx += 1;
3662 }
3663 }
3664 b"strVal" => {
3665 f_str_val = Some(Box::new(CTTLAnimVariantStringVal::from_xml(
3666 reader, &e, false,
3667 )?));
3668 #[cfg(feature = "extra-children")]
3669 {
3670 child_idx += 1;
3671 }
3672 }
3673 b"clrVal" => {
3674 f_clr_val = Some(Box::new(ooxml_dml::types::CTColor::from_xml(
3675 reader, &e, false,
3676 )?));
3677 #[cfg(feature = "extra-children")]
3678 {
3679 child_idx += 1;
3680 }
3681 }
3682 #[cfg(feature = "extra-children")]
3683 _ => {
3684 let elem = RawXmlElement::from_reader(reader, &e)?;
3686 extra_children.push(PositionedNode::new(
3687 child_idx,
3688 RawXmlNode::Element(elem),
3689 ));
3690 child_idx += 1;
3691 }
3692 #[cfg(not(feature = "extra-children"))]
3693 _ => {
3694 skip_element(reader)?;
3696 }
3697 }
3698 }
3699 Event::Empty(e) => {
3700 match e.local_name().as_ref() {
3701 b"boolVal" => {
3702 f_bool_val = Some(Box::new(CTTLAnimVariantBooleanVal::from_xml(
3703 reader, &e, true,
3704 )?));
3705 #[cfg(feature = "extra-children")]
3706 {
3707 child_idx += 1;
3708 }
3709 }
3710 b"intVal" => {
3711 f_int_val = Some(Box::new(CTTLAnimVariantIntegerVal::from_xml(
3712 reader, &e, true,
3713 )?));
3714 #[cfg(feature = "extra-children")]
3715 {
3716 child_idx += 1;
3717 }
3718 }
3719 b"fltVal" => {
3720 f_flt_val = Some(Box::new(CTTLAnimVariantFloatVal::from_xml(
3721 reader, &e, true,
3722 )?));
3723 #[cfg(feature = "extra-children")]
3724 {
3725 child_idx += 1;
3726 }
3727 }
3728 b"strVal" => {
3729 f_str_val = Some(Box::new(CTTLAnimVariantStringVal::from_xml(
3730 reader, &e, true,
3731 )?));
3732 #[cfg(feature = "extra-children")]
3733 {
3734 child_idx += 1;
3735 }
3736 }
3737 b"clrVal" => {
3738 f_clr_val = Some(Box::new(ooxml_dml::types::CTColor::from_xml(
3739 reader, &e, true,
3740 )?));
3741 #[cfg(feature = "extra-children")]
3742 {
3743 child_idx += 1;
3744 }
3745 }
3746 #[cfg(feature = "extra-children")]
3747 _ => {
3748 let elem = RawXmlElement::from_empty(&e);
3750 extra_children.push(PositionedNode::new(
3751 child_idx,
3752 RawXmlNode::Element(elem),
3753 ));
3754 child_idx += 1;
3755 }
3756 #[cfg(not(feature = "extra-children"))]
3757 _ => {}
3758 }
3759 }
3760 Event::End(_) => break,
3761 Event::Eof => break,
3762 _ => {}
3763 }
3764 buf.clear();
3765 }
3766 }
3767
3768 Ok(Self {
3769 bool_val: f_bool_val,
3770 int_val: f_int_val,
3771 flt_val: f_flt_val,
3772 str_val: f_str_val,
3773 clr_val: f_clr_val,
3774 #[cfg(feature = "extra-children")]
3775 extra_children,
3776 })
3777 }
3778}
3779
3780impl FromXml for CTTLTimeAnimateValue {
3781 fn from_xml<R: BufRead>(
3782 reader: &mut Reader<R>,
3783 start_tag: &BytesStart,
3784 is_empty: bool,
3785 ) -> Result<Self, ParseError> {
3786 let mut f_tm = None;
3787 let mut f_fmla = None;
3788 let mut f_value = None;
3789 #[cfg(feature = "extra-attrs")]
3790 let mut extra_attrs = std::collections::HashMap::new();
3791 #[cfg(feature = "extra-children")]
3792 let mut extra_children = Vec::new();
3793 #[cfg(feature = "extra-children")]
3794 let mut child_idx: usize = 0;
3795
3796 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
3798 let val = String::from_utf8_lossy(&attr.value);
3799 match attr.key.local_name().as_ref() {
3800 b"tm" => {
3801 f_tm = Some(val.into_owned());
3802 }
3803 b"fmla" => {
3804 f_fmla = Some(val.into_owned());
3805 }
3806 #[cfg(feature = "extra-attrs")]
3807 unknown => {
3808 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
3809 extra_attrs.insert(key, val.into_owned());
3810 }
3811 #[cfg(not(feature = "extra-attrs"))]
3812 _ => {}
3813 }
3814 }
3815
3816 if !is_empty {
3818 let mut buf = Vec::new();
3819 loop {
3820 match reader.read_event_into(&mut buf)? {
3821 Event::Start(e) => {
3822 match e.local_name().as_ref() {
3823 b"val" => {
3824 f_value =
3825 Some(Box::new(CTTLAnimVariant::from_xml(reader, &e, false)?));
3826 #[cfg(feature = "extra-children")]
3827 {
3828 child_idx += 1;
3829 }
3830 }
3831 #[cfg(feature = "extra-children")]
3832 _ => {
3833 let elem = RawXmlElement::from_reader(reader, &e)?;
3835 extra_children.push(PositionedNode::new(
3836 child_idx,
3837 RawXmlNode::Element(elem),
3838 ));
3839 child_idx += 1;
3840 }
3841 #[cfg(not(feature = "extra-children"))]
3842 _ => {
3843 skip_element(reader)?;
3845 }
3846 }
3847 }
3848 Event::Empty(e) => {
3849 match e.local_name().as_ref() {
3850 b"val" => {
3851 f_value =
3852 Some(Box::new(CTTLAnimVariant::from_xml(reader, &e, true)?));
3853 #[cfg(feature = "extra-children")]
3854 {
3855 child_idx += 1;
3856 }
3857 }
3858 #[cfg(feature = "extra-children")]
3859 _ => {
3860 let elem = RawXmlElement::from_empty(&e);
3862 extra_children.push(PositionedNode::new(
3863 child_idx,
3864 RawXmlNode::Element(elem),
3865 ));
3866 child_idx += 1;
3867 }
3868 #[cfg(not(feature = "extra-children"))]
3869 _ => {}
3870 }
3871 }
3872 Event::End(_) => break,
3873 Event::Eof => break,
3874 _ => {}
3875 }
3876 buf.clear();
3877 }
3878 }
3879
3880 Ok(Self {
3881 tm: f_tm,
3882 fmla: f_fmla,
3883 value: f_value,
3884 #[cfg(feature = "extra-attrs")]
3885 extra_attrs,
3886 #[cfg(feature = "extra-children")]
3887 extra_children,
3888 })
3889 }
3890}
3891
3892impl FromXml for CTTLTimeAnimateValueList {
3893 fn from_xml<R: BufRead>(
3894 reader: &mut Reader<R>,
3895 start_tag: &BytesStart,
3896 is_empty: bool,
3897 ) -> Result<Self, ParseError> {
3898 let mut f_tav = Vec::new();
3899 #[cfg(feature = "extra-children")]
3900 let mut extra_children = Vec::new();
3901 #[cfg(feature = "extra-children")]
3902 let mut child_idx: usize = 0;
3903
3904 if !is_empty {
3906 let mut buf = Vec::new();
3907 loop {
3908 match reader.read_event_into(&mut buf)? {
3909 Event::Start(e) => {
3910 match e.local_name().as_ref() {
3911 b"tav" => {
3912 f_tav.push(CTTLTimeAnimateValue::from_xml(reader, &e, false)?);
3913 #[cfg(feature = "extra-children")]
3914 {
3915 child_idx += 1;
3916 }
3917 }
3918 #[cfg(feature = "extra-children")]
3919 _ => {
3920 let elem = RawXmlElement::from_reader(reader, &e)?;
3922 extra_children.push(PositionedNode::new(
3923 child_idx,
3924 RawXmlNode::Element(elem),
3925 ));
3926 child_idx += 1;
3927 }
3928 #[cfg(not(feature = "extra-children"))]
3929 _ => {
3930 skip_element(reader)?;
3932 }
3933 }
3934 }
3935 Event::Empty(e) => {
3936 match e.local_name().as_ref() {
3937 b"tav" => {
3938 f_tav.push(CTTLTimeAnimateValue::from_xml(reader, &e, true)?);
3939 #[cfg(feature = "extra-children")]
3940 {
3941 child_idx += 1;
3942 }
3943 }
3944 #[cfg(feature = "extra-children")]
3945 _ => {
3946 let elem = RawXmlElement::from_empty(&e);
3948 extra_children.push(PositionedNode::new(
3949 child_idx,
3950 RawXmlNode::Element(elem),
3951 ));
3952 child_idx += 1;
3953 }
3954 #[cfg(not(feature = "extra-children"))]
3955 _ => {}
3956 }
3957 }
3958 Event::End(_) => break,
3959 Event::Eof => break,
3960 _ => {}
3961 }
3962 buf.clear();
3963 }
3964 }
3965
3966 Ok(Self {
3967 tav: f_tav,
3968 #[cfg(feature = "extra-children")]
3969 extra_children,
3970 })
3971 }
3972}
3973
3974impl FromXml for CTTLAnimateBehavior {
3975 fn from_xml<R: BufRead>(
3976 reader: &mut Reader<R>,
3977 start_tag: &BytesStart,
3978 is_empty: bool,
3979 ) -> Result<Self, ParseError> {
3980 let mut f_by = None;
3981 let mut f_from = None;
3982 let mut f_to = None;
3983 let mut f_calcmode = None;
3984 let mut f_value_type = None;
3985 let mut f_c_bhvr: Option<Box<CTTLCommonBehaviorData>> = None;
3986 let mut f_tav_lst = None;
3987 #[cfg(feature = "extra-attrs")]
3988 let mut extra_attrs = std::collections::HashMap::new();
3989 #[cfg(feature = "extra-children")]
3990 let mut extra_children = Vec::new();
3991 #[cfg(feature = "extra-children")]
3992 let mut child_idx: usize = 0;
3993
3994 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
3996 let val = String::from_utf8_lossy(&attr.value);
3997 match attr.key.local_name().as_ref() {
3998 b"by" => {
3999 f_by = Some(val.into_owned());
4000 }
4001 b"from" => {
4002 f_from = Some(val.into_owned());
4003 }
4004 b"to" => {
4005 f_to = Some(val.into_owned());
4006 }
4007 b"calcmode" => {
4008 f_calcmode = val.parse().ok();
4009 }
4010 b"valueType" => {
4011 f_value_type = val.parse().ok();
4012 }
4013 #[cfg(feature = "extra-attrs")]
4014 unknown => {
4015 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
4016 extra_attrs.insert(key, val.into_owned());
4017 }
4018 #[cfg(not(feature = "extra-attrs"))]
4019 _ => {}
4020 }
4021 }
4022
4023 if !is_empty {
4025 let mut buf = Vec::new();
4026 loop {
4027 match reader.read_event_into(&mut buf)? {
4028 Event::Start(e) => {
4029 match e.local_name().as_ref() {
4030 b"cBhvr" => {
4031 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
4032 reader, &e, false,
4033 )?));
4034 #[cfg(feature = "extra-children")]
4035 {
4036 child_idx += 1;
4037 }
4038 }
4039 b"tavLst" => {
4040 f_tav_lst = Some(Box::new(CTTLTimeAnimateValueList::from_xml(
4041 reader, &e, false,
4042 )?));
4043 #[cfg(feature = "extra-children")]
4044 {
4045 child_idx += 1;
4046 }
4047 }
4048 #[cfg(feature = "extra-children")]
4049 _ => {
4050 let elem = RawXmlElement::from_reader(reader, &e)?;
4052 extra_children.push(PositionedNode::new(
4053 child_idx,
4054 RawXmlNode::Element(elem),
4055 ));
4056 child_idx += 1;
4057 }
4058 #[cfg(not(feature = "extra-children"))]
4059 _ => {
4060 skip_element(reader)?;
4062 }
4063 }
4064 }
4065 Event::Empty(e) => {
4066 match e.local_name().as_ref() {
4067 b"cBhvr" => {
4068 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
4069 reader, &e, true,
4070 )?));
4071 #[cfg(feature = "extra-children")]
4072 {
4073 child_idx += 1;
4074 }
4075 }
4076 b"tavLst" => {
4077 f_tav_lst = Some(Box::new(CTTLTimeAnimateValueList::from_xml(
4078 reader, &e, true,
4079 )?));
4080 #[cfg(feature = "extra-children")]
4081 {
4082 child_idx += 1;
4083 }
4084 }
4085 #[cfg(feature = "extra-children")]
4086 _ => {
4087 let elem = RawXmlElement::from_empty(&e);
4089 extra_children.push(PositionedNode::new(
4090 child_idx,
4091 RawXmlNode::Element(elem),
4092 ));
4093 child_idx += 1;
4094 }
4095 #[cfg(not(feature = "extra-children"))]
4096 _ => {}
4097 }
4098 }
4099 Event::End(_) => break,
4100 Event::Eof => break,
4101 _ => {}
4102 }
4103 buf.clear();
4104 }
4105 }
4106
4107 Ok(Self {
4108 by: f_by,
4109 from: f_from,
4110 to: f_to,
4111 calcmode: f_calcmode,
4112 value_type: f_value_type,
4113 c_bhvr: f_c_bhvr.ok_or_else(|| ParseError::MissingAttribute("cBhvr".to_string()))?,
4114 tav_lst: f_tav_lst,
4115 #[cfg(feature = "extra-attrs")]
4116 extra_attrs,
4117 #[cfg(feature = "extra-children")]
4118 extra_children,
4119 })
4120 }
4121}
4122
4123impl FromXml for CTTLByRgbColorTransform {
4124 fn from_xml<R: BufRead>(
4125 reader: &mut Reader<R>,
4126 start_tag: &BytesStart,
4127 is_empty: bool,
4128 ) -> Result<Self, ParseError> {
4129 let mut f_reference: Option<ooxml_dml::types::STFixedPercentage> = None;
4130 let mut f_g: Option<ooxml_dml::types::STFixedPercentage> = None;
4131 let mut f_b: Option<ooxml_dml::types::STFixedPercentage> = None;
4132 #[cfg(feature = "extra-attrs")]
4133 let mut extra_attrs = std::collections::HashMap::new();
4134
4135 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
4137 let val = String::from_utf8_lossy(&attr.value);
4138 match attr.key.local_name().as_ref() {
4139 b"r" => {
4140 f_reference = val.parse().ok();
4141 }
4142 b"g" => {
4143 f_g = val.parse().ok();
4144 }
4145 b"b" => {
4146 f_b = val.parse().ok();
4147 }
4148 #[cfg(feature = "extra-attrs")]
4149 unknown => {
4150 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
4151 extra_attrs.insert(key, val.into_owned());
4152 }
4153 #[cfg(not(feature = "extra-attrs"))]
4154 _ => {}
4155 }
4156 }
4157
4158 if !is_empty {
4159 let mut buf = Vec::new();
4160 loop {
4161 match reader.read_event_into(&mut buf)? {
4162 Event::End(_) => break,
4163 Event::Eof => break,
4164 _ => {}
4165 }
4166 buf.clear();
4167 }
4168 }
4169
4170 Ok(Self {
4171 reference: f_reference.ok_or_else(|| ParseError::MissingAttribute("r".to_string()))?,
4172 g: f_g.ok_or_else(|| ParseError::MissingAttribute("g".to_string()))?,
4173 b: f_b.ok_or_else(|| ParseError::MissingAttribute("b".to_string()))?,
4174 #[cfg(feature = "extra-attrs")]
4175 extra_attrs,
4176 })
4177 }
4178}
4179
4180impl FromXml for CTTLByHslColorTransform {
4181 fn from_xml<R: BufRead>(
4182 reader: &mut Reader<R>,
4183 start_tag: &BytesStart,
4184 is_empty: bool,
4185 ) -> Result<Self, ParseError> {
4186 let mut f_height: Option<ooxml_dml::types::STAngle> = None;
4187 let mut f_s: Option<ooxml_dml::types::STFixedPercentage> = None;
4188 let mut f_l: Option<ooxml_dml::types::STFixedPercentage> = None;
4189 #[cfg(feature = "extra-attrs")]
4190 let mut extra_attrs = std::collections::HashMap::new();
4191
4192 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
4194 let val = String::from_utf8_lossy(&attr.value);
4195 match attr.key.local_name().as_ref() {
4196 b"h" => {
4197 f_height = val.parse().ok();
4198 }
4199 b"s" => {
4200 f_s = val.parse().ok();
4201 }
4202 b"l" => {
4203 f_l = val.parse().ok();
4204 }
4205 #[cfg(feature = "extra-attrs")]
4206 unknown => {
4207 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
4208 extra_attrs.insert(key, val.into_owned());
4209 }
4210 #[cfg(not(feature = "extra-attrs"))]
4211 _ => {}
4212 }
4213 }
4214
4215 if !is_empty {
4216 let mut buf = Vec::new();
4217 loop {
4218 match reader.read_event_into(&mut buf)? {
4219 Event::End(_) => break,
4220 Event::Eof => break,
4221 _ => {}
4222 }
4223 buf.clear();
4224 }
4225 }
4226
4227 Ok(Self {
4228 height: f_height.ok_or_else(|| ParseError::MissingAttribute("h".to_string()))?,
4229 s: f_s.ok_or_else(|| ParseError::MissingAttribute("s".to_string()))?,
4230 l: f_l.ok_or_else(|| ParseError::MissingAttribute("l".to_string()))?,
4231 #[cfg(feature = "extra-attrs")]
4232 extra_attrs,
4233 })
4234 }
4235}
4236
4237impl FromXml for CTTLByAnimateColorTransform {
4238 fn from_xml<R: BufRead>(
4239 reader: &mut Reader<R>,
4240 start_tag: &BytesStart,
4241 is_empty: bool,
4242 ) -> Result<Self, ParseError> {
4243 let mut f_rgb = None;
4244 let mut f_hsl = None;
4245 #[cfg(feature = "extra-children")]
4246 let mut extra_children = Vec::new();
4247 #[cfg(feature = "extra-children")]
4248 let mut child_idx: usize = 0;
4249
4250 if !is_empty {
4252 let mut buf = Vec::new();
4253 loop {
4254 match reader.read_event_into(&mut buf)? {
4255 Event::Start(e) => {
4256 match e.local_name().as_ref() {
4257 b"rgb" => {
4258 f_rgb = Some(Box::new(CTTLByRgbColorTransform::from_xml(
4259 reader, &e, false,
4260 )?));
4261 #[cfg(feature = "extra-children")]
4262 {
4263 child_idx += 1;
4264 }
4265 }
4266 b"hsl" => {
4267 f_hsl = Some(Box::new(CTTLByHslColorTransform::from_xml(
4268 reader, &e, false,
4269 )?));
4270 #[cfg(feature = "extra-children")]
4271 {
4272 child_idx += 1;
4273 }
4274 }
4275 #[cfg(feature = "extra-children")]
4276 _ => {
4277 let elem = RawXmlElement::from_reader(reader, &e)?;
4279 extra_children.push(PositionedNode::new(
4280 child_idx,
4281 RawXmlNode::Element(elem),
4282 ));
4283 child_idx += 1;
4284 }
4285 #[cfg(not(feature = "extra-children"))]
4286 _ => {
4287 skip_element(reader)?;
4289 }
4290 }
4291 }
4292 Event::Empty(e) => {
4293 match e.local_name().as_ref() {
4294 b"rgb" => {
4295 f_rgb = Some(Box::new(CTTLByRgbColorTransform::from_xml(
4296 reader, &e, true,
4297 )?));
4298 #[cfg(feature = "extra-children")]
4299 {
4300 child_idx += 1;
4301 }
4302 }
4303 b"hsl" => {
4304 f_hsl = Some(Box::new(CTTLByHslColorTransform::from_xml(
4305 reader, &e, true,
4306 )?));
4307 #[cfg(feature = "extra-children")]
4308 {
4309 child_idx += 1;
4310 }
4311 }
4312 #[cfg(feature = "extra-children")]
4313 _ => {
4314 let elem = RawXmlElement::from_empty(&e);
4316 extra_children.push(PositionedNode::new(
4317 child_idx,
4318 RawXmlNode::Element(elem),
4319 ));
4320 child_idx += 1;
4321 }
4322 #[cfg(not(feature = "extra-children"))]
4323 _ => {}
4324 }
4325 }
4326 Event::End(_) => break,
4327 Event::Eof => break,
4328 _ => {}
4329 }
4330 buf.clear();
4331 }
4332 }
4333
4334 Ok(Self {
4335 rgb: f_rgb,
4336 hsl: f_hsl,
4337 #[cfg(feature = "extra-children")]
4338 extra_children,
4339 })
4340 }
4341}
4342
4343impl FromXml for CTTLAnimateColorBehavior {
4344 fn from_xml<R: BufRead>(
4345 reader: &mut Reader<R>,
4346 start_tag: &BytesStart,
4347 is_empty: bool,
4348 ) -> Result<Self, ParseError> {
4349 let mut f_clr_spc = None;
4350 let mut f_dir = None;
4351 let mut f_c_bhvr: Option<Box<CTTLCommonBehaviorData>> = None;
4352 let mut f_by = None;
4353 let mut f_from = None;
4354 let mut f_to = None;
4355 #[cfg(feature = "extra-attrs")]
4356 let mut extra_attrs = std::collections::HashMap::new();
4357 #[cfg(feature = "extra-children")]
4358 let mut extra_children = Vec::new();
4359 #[cfg(feature = "extra-children")]
4360 let mut child_idx: usize = 0;
4361
4362 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
4364 let val = String::from_utf8_lossy(&attr.value);
4365 match attr.key.local_name().as_ref() {
4366 b"clrSpc" => {
4367 f_clr_spc = val.parse().ok();
4368 }
4369 b"dir" => {
4370 f_dir = val.parse().ok();
4371 }
4372 #[cfg(feature = "extra-attrs")]
4373 unknown => {
4374 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
4375 extra_attrs.insert(key, val.into_owned());
4376 }
4377 #[cfg(not(feature = "extra-attrs"))]
4378 _ => {}
4379 }
4380 }
4381
4382 if !is_empty {
4384 let mut buf = Vec::new();
4385 loop {
4386 match reader.read_event_into(&mut buf)? {
4387 Event::Start(e) => {
4388 match e.local_name().as_ref() {
4389 b"cBhvr" => {
4390 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
4391 reader, &e, false,
4392 )?));
4393 #[cfg(feature = "extra-children")]
4394 {
4395 child_idx += 1;
4396 }
4397 }
4398 b"by" => {
4399 f_by = Some(Box::new(CTTLByAnimateColorTransform::from_xml(
4400 reader, &e, false,
4401 )?));
4402 #[cfg(feature = "extra-children")]
4403 {
4404 child_idx += 1;
4405 }
4406 }
4407 b"from" => {
4408 f_from = Some(Box::new(ooxml_dml::types::CTColor::from_xml(
4409 reader, &e, false,
4410 )?));
4411 #[cfg(feature = "extra-children")]
4412 {
4413 child_idx += 1;
4414 }
4415 }
4416 b"to" => {
4417 f_to = Some(Box::new(ooxml_dml::types::CTColor::from_xml(
4418 reader, &e, false,
4419 )?));
4420 #[cfg(feature = "extra-children")]
4421 {
4422 child_idx += 1;
4423 }
4424 }
4425 #[cfg(feature = "extra-children")]
4426 _ => {
4427 let elem = RawXmlElement::from_reader(reader, &e)?;
4429 extra_children.push(PositionedNode::new(
4430 child_idx,
4431 RawXmlNode::Element(elem),
4432 ));
4433 child_idx += 1;
4434 }
4435 #[cfg(not(feature = "extra-children"))]
4436 _ => {
4437 skip_element(reader)?;
4439 }
4440 }
4441 }
4442 Event::Empty(e) => {
4443 match e.local_name().as_ref() {
4444 b"cBhvr" => {
4445 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
4446 reader, &e, true,
4447 )?));
4448 #[cfg(feature = "extra-children")]
4449 {
4450 child_idx += 1;
4451 }
4452 }
4453 b"by" => {
4454 f_by = Some(Box::new(CTTLByAnimateColorTransform::from_xml(
4455 reader, &e, true,
4456 )?));
4457 #[cfg(feature = "extra-children")]
4458 {
4459 child_idx += 1;
4460 }
4461 }
4462 b"from" => {
4463 f_from = Some(Box::new(ooxml_dml::types::CTColor::from_xml(
4464 reader, &e, true,
4465 )?));
4466 #[cfg(feature = "extra-children")]
4467 {
4468 child_idx += 1;
4469 }
4470 }
4471 b"to" => {
4472 f_to = Some(Box::new(ooxml_dml::types::CTColor::from_xml(
4473 reader, &e, true,
4474 )?));
4475 #[cfg(feature = "extra-children")]
4476 {
4477 child_idx += 1;
4478 }
4479 }
4480 #[cfg(feature = "extra-children")]
4481 _ => {
4482 let elem = RawXmlElement::from_empty(&e);
4484 extra_children.push(PositionedNode::new(
4485 child_idx,
4486 RawXmlNode::Element(elem),
4487 ));
4488 child_idx += 1;
4489 }
4490 #[cfg(not(feature = "extra-children"))]
4491 _ => {}
4492 }
4493 }
4494 Event::End(_) => break,
4495 Event::Eof => break,
4496 _ => {}
4497 }
4498 buf.clear();
4499 }
4500 }
4501
4502 Ok(Self {
4503 clr_spc: f_clr_spc,
4504 dir: f_dir,
4505 c_bhvr: f_c_bhvr.ok_or_else(|| ParseError::MissingAttribute("cBhvr".to_string()))?,
4506 by: f_by,
4507 from: f_from,
4508 to: f_to,
4509 #[cfg(feature = "extra-attrs")]
4510 extra_attrs,
4511 #[cfg(feature = "extra-children")]
4512 extra_children,
4513 })
4514 }
4515}
4516
4517impl FromXml for CTTLAnimateEffectBehavior {
4518 fn from_xml<R: BufRead>(
4519 reader: &mut Reader<R>,
4520 start_tag: &BytesStart,
4521 is_empty: bool,
4522 ) -> Result<Self, ParseError> {
4523 let mut f_transition = None;
4524 let mut f_filter = None;
4525 let mut f_pr_lst = None;
4526 let mut f_c_bhvr: Option<Box<CTTLCommonBehaviorData>> = None;
4527 let mut f_progress = None;
4528 #[cfg(feature = "extra-attrs")]
4529 let mut extra_attrs = std::collections::HashMap::new();
4530 #[cfg(feature = "extra-children")]
4531 let mut extra_children = Vec::new();
4532 #[cfg(feature = "extra-children")]
4533 let mut child_idx: usize = 0;
4534
4535 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
4537 let val = String::from_utf8_lossy(&attr.value);
4538 match attr.key.local_name().as_ref() {
4539 b"transition" => {
4540 f_transition = val.parse().ok();
4541 }
4542 b"filter" => {
4543 f_filter = Some(val.into_owned());
4544 }
4545 b"prLst" => {
4546 f_pr_lst = Some(val.into_owned());
4547 }
4548 #[cfg(feature = "extra-attrs")]
4549 unknown => {
4550 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
4551 extra_attrs.insert(key, val.into_owned());
4552 }
4553 #[cfg(not(feature = "extra-attrs"))]
4554 _ => {}
4555 }
4556 }
4557
4558 if !is_empty {
4560 let mut buf = Vec::new();
4561 loop {
4562 match reader.read_event_into(&mut buf)? {
4563 Event::Start(e) => {
4564 match e.local_name().as_ref() {
4565 b"cBhvr" => {
4566 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
4567 reader, &e, false,
4568 )?));
4569 #[cfg(feature = "extra-children")]
4570 {
4571 child_idx += 1;
4572 }
4573 }
4574 b"progress" => {
4575 f_progress =
4576 Some(Box::new(CTTLAnimVariant::from_xml(reader, &e, false)?));
4577 #[cfg(feature = "extra-children")]
4578 {
4579 child_idx += 1;
4580 }
4581 }
4582 #[cfg(feature = "extra-children")]
4583 _ => {
4584 let elem = RawXmlElement::from_reader(reader, &e)?;
4586 extra_children.push(PositionedNode::new(
4587 child_idx,
4588 RawXmlNode::Element(elem),
4589 ));
4590 child_idx += 1;
4591 }
4592 #[cfg(not(feature = "extra-children"))]
4593 _ => {
4594 skip_element(reader)?;
4596 }
4597 }
4598 }
4599 Event::Empty(e) => {
4600 match e.local_name().as_ref() {
4601 b"cBhvr" => {
4602 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
4603 reader, &e, true,
4604 )?));
4605 #[cfg(feature = "extra-children")]
4606 {
4607 child_idx += 1;
4608 }
4609 }
4610 b"progress" => {
4611 f_progress =
4612 Some(Box::new(CTTLAnimVariant::from_xml(reader, &e, true)?));
4613 #[cfg(feature = "extra-children")]
4614 {
4615 child_idx += 1;
4616 }
4617 }
4618 #[cfg(feature = "extra-children")]
4619 _ => {
4620 let elem = RawXmlElement::from_empty(&e);
4622 extra_children.push(PositionedNode::new(
4623 child_idx,
4624 RawXmlNode::Element(elem),
4625 ));
4626 child_idx += 1;
4627 }
4628 #[cfg(not(feature = "extra-children"))]
4629 _ => {}
4630 }
4631 }
4632 Event::End(_) => break,
4633 Event::Eof => break,
4634 _ => {}
4635 }
4636 buf.clear();
4637 }
4638 }
4639
4640 Ok(Self {
4641 transition: f_transition,
4642 filter: f_filter,
4643 pr_lst: f_pr_lst,
4644 c_bhvr: f_c_bhvr.ok_or_else(|| ParseError::MissingAttribute("cBhvr".to_string()))?,
4645 progress: f_progress,
4646 #[cfg(feature = "extra-attrs")]
4647 extra_attrs,
4648 #[cfg(feature = "extra-children")]
4649 extra_children,
4650 })
4651 }
4652}
4653
4654impl FromXml for CTTLPoint {
4655 fn from_xml<R: BufRead>(
4656 reader: &mut Reader<R>,
4657 start_tag: &BytesStart,
4658 is_empty: bool,
4659 ) -> Result<Self, ParseError> {
4660 let mut f_x: Option<ooxml_dml::types::STPercentage> = None;
4661 let mut f_y: Option<ooxml_dml::types::STPercentage> = None;
4662 #[cfg(feature = "extra-attrs")]
4663 let mut extra_attrs = std::collections::HashMap::new();
4664
4665 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
4667 let val = String::from_utf8_lossy(&attr.value);
4668 match attr.key.local_name().as_ref() {
4669 b"x" => {
4670 f_x = val.parse().ok();
4671 }
4672 b"y" => {
4673 f_y = val.parse().ok();
4674 }
4675 #[cfg(feature = "extra-attrs")]
4676 unknown => {
4677 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
4678 extra_attrs.insert(key, val.into_owned());
4679 }
4680 #[cfg(not(feature = "extra-attrs"))]
4681 _ => {}
4682 }
4683 }
4684
4685 if !is_empty {
4686 let mut buf = Vec::new();
4687 loop {
4688 match reader.read_event_into(&mut buf)? {
4689 Event::End(_) => break,
4690 Event::Eof => break,
4691 _ => {}
4692 }
4693 buf.clear();
4694 }
4695 }
4696
4697 Ok(Self {
4698 x: f_x.ok_or_else(|| ParseError::MissingAttribute("x".to_string()))?,
4699 y: f_y.ok_or_else(|| ParseError::MissingAttribute("y".to_string()))?,
4700 #[cfg(feature = "extra-attrs")]
4701 extra_attrs,
4702 })
4703 }
4704}
4705
4706impl FromXml for CTTLAnimateMotionBehavior {
4707 fn from_xml<R: BufRead>(
4708 reader: &mut Reader<R>,
4709 start_tag: &BytesStart,
4710 is_empty: bool,
4711 ) -> Result<Self, ParseError> {
4712 let mut f_origin = None;
4713 let mut f_path = None;
4714 let mut f_path_edit_mode = None;
4715 let mut f_r_ang = None;
4716 let mut f_pts_types = None;
4717 let mut f_c_bhvr: Option<Box<CTTLCommonBehaviorData>> = None;
4718 let mut f_by = None;
4719 let mut f_from = None;
4720 let mut f_to = None;
4721 let mut f_r_ctr = None;
4722 #[cfg(feature = "extra-attrs")]
4723 let mut extra_attrs = std::collections::HashMap::new();
4724 #[cfg(feature = "extra-children")]
4725 let mut extra_children = Vec::new();
4726 #[cfg(feature = "extra-children")]
4727 let mut child_idx: usize = 0;
4728
4729 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
4731 let val = String::from_utf8_lossy(&attr.value);
4732 match attr.key.local_name().as_ref() {
4733 b"origin" => {
4734 f_origin = val.parse().ok();
4735 }
4736 b"path" => {
4737 f_path = Some(val.into_owned());
4738 }
4739 b"pathEditMode" => {
4740 f_path_edit_mode = val.parse().ok();
4741 }
4742 b"rAng" => {
4743 f_r_ang = val.parse().ok();
4744 }
4745 b"ptsTypes" => {
4746 f_pts_types = Some(val.into_owned());
4747 }
4748 #[cfg(feature = "extra-attrs")]
4749 unknown => {
4750 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
4751 extra_attrs.insert(key, val.into_owned());
4752 }
4753 #[cfg(not(feature = "extra-attrs"))]
4754 _ => {}
4755 }
4756 }
4757
4758 if !is_empty {
4760 let mut buf = Vec::new();
4761 loop {
4762 match reader.read_event_into(&mut buf)? {
4763 Event::Start(e) => {
4764 match e.local_name().as_ref() {
4765 b"cBhvr" => {
4766 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
4767 reader, &e, false,
4768 )?));
4769 #[cfg(feature = "extra-children")]
4770 {
4771 child_idx += 1;
4772 }
4773 }
4774 b"by" => {
4775 f_by = Some(Box::new(CTTLPoint::from_xml(reader, &e, false)?));
4776 #[cfg(feature = "extra-children")]
4777 {
4778 child_idx += 1;
4779 }
4780 }
4781 b"from" => {
4782 f_from = Some(Box::new(CTTLPoint::from_xml(reader, &e, false)?));
4783 #[cfg(feature = "extra-children")]
4784 {
4785 child_idx += 1;
4786 }
4787 }
4788 b"to" => {
4789 f_to = Some(Box::new(CTTLPoint::from_xml(reader, &e, false)?));
4790 #[cfg(feature = "extra-children")]
4791 {
4792 child_idx += 1;
4793 }
4794 }
4795 b"rCtr" => {
4796 f_r_ctr = Some(Box::new(CTTLPoint::from_xml(reader, &e, false)?));
4797 #[cfg(feature = "extra-children")]
4798 {
4799 child_idx += 1;
4800 }
4801 }
4802 #[cfg(feature = "extra-children")]
4803 _ => {
4804 let elem = RawXmlElement::from_reader(reader, &e)?;
4806 extra_children.push(PositionedNode::new(
4807 child_idx,
4808 RawXmlNode::Element(elem),
4809 ));
4810 child_idx += 1;
4811 }
4812 #[cfg(not(feature = "extra-children"))]
4813 _ => {
4814 skip_element(reader)?;
4816 }
4817 }
4818 }
4819 Event::Empty(e) => {
4820 match e.local_name().as_ref() {
4821 b"cBhvr" => {
4822 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
4823 reader, &e, true,
4824 )?));
4825 #[cfg(feature = "extra-children")]
4826 {
4827 child_idx += 1;
4828 }
4829 }
4830 b"by" => {
4831 f_by = Some(Box::new(CTTLPoint::from_xml(reader, &e, true)?));
4832 #[cfg(feature = "extra-children")]
4833 {
4834 child_idx += 1;
4835 }
4836 }
4837 b"from" => {
4838 f_from = Some(Box::new(CTTLPoint::from_xml(reader, &e, true)?));
4839 #[cfg(feature = "extra-children")]
4840 {
4841 child_idx += 1;
4842 }
4843 }
4844 b"to" => {
4845 f_to = Some(Box::new(CTTLPoint::from_xml(reader, &e, true)?));
4846 #[cfg(feature = "extra-children")]
4847 {
4848 child_idx += 1;
4849 }
4850 }
4851 b"rCtr" => {
4852 f_r_ctr = Some(Box::new(CTTLPoint::from_xml(reader, &e, true)?));
4853 #[cfg(feature = "extra-children")]
4854 {
4855 child_idx += 1;
4856 }
4857 }
4858 #[cfg(feature = "extra-children")]
4859 _ => {
4860 let elem = RawXmlElement::from_empty(&e);
4862 extra_children.push(PositionedNode::new(
4863 child_idx,
4864 RawXmlNode::Element(elem),
4865 ));
4866 child_idx += 1;
4867 }
4868 #[cfg(not(feature = "extra-children"))]
4869 _ => {}
4870 }
4871 }
4872 Event::End(_) => break,
4873 Event::Eof => break,
4874 _ => {}
4875 }
4876 buf.clear();
4877 }
4878 }
4879
4880 Ok(Self {
4881 origin: f_origin,
4882 path: f_path,
4883 path_edit_mode: f_path_edit_mode,
4884 r_ang: f_r_ang,
4885 pts_types: f_pts_types,
4886 c_bhvr: f_c_bhvr.ok_or_else(|| ParseError::MissingAttribute("cBhvr".to_string()))?,
4887 by: f_by,
4888 from: f_from,
4889 to: f_to,
4890 r_ctr: f_r_ctr,
4891 #[cfg(feature = "extra-attrs")]
4892 extra_attrs,
4893 #[cfg(feature = "extra-children")]
4894 extra_children,
4895 })
4896 }
4897}
4898
4899impl FromXml for CTTLAnimateRotationBehavior {
4900 fn from_xml<R: BufRead>(
4901 reader: &mut Reader<R>,
4902 start_tag: &BytesStart,
4903 is_empty: bool,
4904 ) -> Result<Self, ParseError> {
4905 let mut f_by = None;
4906 let mut f_from = None;
4907 let mut f_to = None;
4908 let mut f_c_bhvr: Option<Box<CTTLCommonBehaviorData>> = None;
4909 #[cfg(feature = "extra-attrs")]
4910 let mut extra_attrs = std::collections::HashMap::new();
4911 #[cfg(feature = "extra-children")]
4912 let mut extra_children = Vec::new();
4913 #[cfg(feature = "extra-children")]
4914 let mut child_idx: usize = 0;
4915
4916 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
4918 let val = String::from_utf8_lossy(&attr.value);
4919 match attr.key.local_name().as_ref() {
4920 b"by" => {
4921 f_by = val.parse().ok();
4922 }
4923 b"from" => {
4924 f_from = val.parse().ok();
4925 }
4926 b"to" => {
4927 f_to = val.parse().ok();
4928 }
4929 #[cfg(feature = "extra-attrs")]
4930 unknown => {
4931 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
4932 extra_attrs.insert(key, val.into_owned());
4933 }
4934 #[cfg(not(feature = "extra-attrs"))]
4935 _ => {}
4936 }
4937 }
4938
4939 if !is_empty {
4941 let mut buf = Vec::new();
4942 loop {
4943 match reader.read_event_into(&mut buf)? {
4944 Event::Start(e) => {
4945 match e.local_name().as_ref() {
4946 b"cBhvr" => {
4947 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
4948 reader, &e, false,
4949 )?));
4950 #[cfg(feature = "extra-children")]
4951 {
4952 child_idx += 1;
4953 }
4954 }
4955 #[cfg(feature = "extra-children")]
4956 _ => {
4957 let elem = RawXmlElement::from_reader(reader, &e)?;
4959 extra_children.push(PositionedNode::new(
4960 child_idx,
4961 RawXmlNode::Element(elem),
4962 ));
4963 child_idx += 1;
4964 }
4965 #[cfg(not(feature = "extra-children"))]
4966 _ => {
4967 skip_element(reader)?;
4969 }
4970 }
4971 }
4972 Event::Empty(e) => {
4973 match e.local_name().as_ref() {
4974 b"cBhvr" => {
4975 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
4976 reader, &e, true,
4977 )?));
4978 #[cfg(feature = "extra-children")]
4979 {
4980 child_idx += 1;
4981 }
4982 }
4983 #[cfg(feature = "extra-children")]
4984 _ => {
4985 let elem = RawXmlElement::from_empty(&e);
4987 extra_children.push(PositionedNode::new(
4988 child_idx,
4989 RawXmlNode::Element(elem),
4990 ));
4991 child_idx += 1;
4992 }
4993 #[cfg(not(feature = "extra-children"))]
4994 _ => {}
4995 }
4996 }
4997 Event::End(_) => break,
4998 Event::Eof => break,
4999 _ => {}
5000 }
5001 buf.clear();
5002 }
5003 }
5004
5005 Ok(Self {
5006 by: f_by,
5007 from: f_from,
5008 to: f_to,
5009 c_bhvr: f_c_bhvr.ok_or_else(|| ParseError::MissingAttribute("cBhvr".to_string()))?,
5010 #[cfg(feature = "extra-attrs")]
5011 extra_attrs,
5012 #[cfg(feature = "extra-children")]
5013 extra_children,
5014 })
5015 }
5016}
5017
5018impl FromXml for CTTLAnimateScaleBehavior {
5019 fn from_xml<R: BufRead>(
5020 reader: &mut Reader<R>,
5021 start_tag: &BytesStart,
5022 is_empty: bool,
5023 ) -> Result<Self, ParseError> {
5024 let mut f_zoom_contents = None;
5025 let mut f_c_bhvr: Option<Box<CTTLCommonBehaviorData>> = None;
5026 let mut f_by = None;
5027 let mut f_from = None;
5028 let mut f_to = None;
5029 #[cfg(feature = "extra-attrs")]
5030 let mut extra_attrs = std::collections::HashMap::new();
5031 #[cfg(feature = "extra-children")]
5032 let mut extra_children = Vec::new();
5033 #[cfg(feature = "extra-children")]
5034 let mut child_idx: usize = 0;
5035
5036 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
5038 let val = String::from_utf8_lossy(&attr.value);
5039 match attr.key.local_name().as_ref() {
5040 b"zoomContents" => {
5041 f_zoom_contents = Some(val == "true" || val == "1");
5042 }
5043 #[cfg(feature = "extra-attrs")]
5044 unknown => {
5045 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
5046 extra_attrs.insert(key, val.into_owned());
5047 }
5048 #[cfg(not(feature = "extra-attrs"))]
5049 _ => {}
5050 }
5051 }
5052
5053 if !is_empty {
5055 let mut buf = Vec::new();
5056 loop {
5057 match reader.read_event_into(&mut buf)? {
5058 Event::Start(e) => {
5059 match e.local_name().as_ref() {
5060 b"cBhvr" => {
5061 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
5062 reader, &e, false,
5063 )?));
5064 #[cfg(feature = "extra-children")]
5065 {
5066 child_idx += 1;
5067 }
5068 }
5069 b"by" => {
5070 f_by = Some(Box::new(CTTLPoint::from_xml(reader, &e, false)?));
5071 #[cfg(feature = "extra-children")]
5072 {
5073 child_idx += 1;
5074 }
5075 }
5076 b"from" => {
5077 f_from = Some(Box::new(CTTLPoint::from_xml(reader, &e, false)?));
5078 #[cfg(feature = "extra-children")]
5079 {
5080 child_idx += 1;
5081 }
5082 }
5083 b"to" => {
5084 f_to = Some(Box::new(CTTLPoint::from_xml(reader, &e, false)?));
5085 #[cfg(feature = "extra-children")]
5086 {
5087 child_idx += 1;
5088 }
5089 }
5090 #[cfg(feature = "extra-children")]
5091 _ => {
5092 let elem = RawXmlElement::from_reader(reader, &e)?;
5094 extra_children.push(PositionedNode::new(
5095 child_idx,
5096 RawXmlNode::Element(elem),
5097 ));
5098 child_idx += 1;
5099 }
5100 #[cfg(not(feature = "extra-children"))]
5101 _ => {
5102 skip_element(reader)?;
5104 }
5105 }
5106 }
5107 Event::Empty(e) => {
5108 match e.local_name().as_ref() {
5109 b"cBhvr" => {
5110 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
5111 reader, &e, true,
5112 )?));
5113 #[cfg(feature = "extra-children")]
5114 {
5115 child_idx += 1;
5116 }
5117 }
5118 b"by" => {
5119 f_by = Some(Box::new(CTTLPoint::from_xml(reader, &e, true)?));
5120 #[cfg(feature = "extra-children")]
5121 {
5122 child_idx += 1;
5123 }
5124 }
5125 b"from" => {
5126 f_from = Some(Box::new(CTTLPoint::from_xml(reader, &e, true)?));
5127 #[cfg(feature = "extra-children")]
5128 {
5129 child_idx += 1;
5130 }
5131 }
5132 b"to" => {
5133 f_to = Some(Box::new(CTTLPoint::from_xml(reader, &e, true)?));
5134 #[cfg(feature = "extra-children")]
5135 {
5136 child_idx += 1;
5137 }
5138 }
5139 #[cfg(feature = "extra-children")]
5140 _ => {
5141 let elem = RawXmlElement::from_empty(&e);
5143 extra_children.push(PositionedNode::new(
5144 child_idx,
5145 RawXmlNode::Element(elem),
5146 ));
5147 child_idx += 1;
5148 }
5149 #[cfg(not(feature = "extra-children"))]
5150 _ => {}
5151 }
5152 }
5153 Event::End(_) => break,
5154 Event::Eof => break,
5155 _ => {}
5156 }
5157 buf.clear();
5158 }
5159 }
5160
5161 Ok(Self {
5162 zoom_contents: f_zoom_contents,
5163 c_bhvr: f_c_bhvr.ok_or_else(|| ParseError::MissingAttribute("cBhvr".to_string()))?,
5164 by: f_by,
5165 from: f_from,
5166 to: f_to,
5167 #[cfg(feature = "extra-attrs")]
5168 extra_attrs,
5169 #[cfg(feature = "extra-children")]
5170 extra_children,
5171 })
5172 }
5173}
5174
5175impl FromXml for CTTLCommandBehavior {
5176 fn from_xml<R: BufRead>(
5177 reader: &mut Reader<R>,
5178 start_tag: &BytesStart,
5179 is_empty: bool,
5180 ) -> Result<Self, ParseError> {
5181 let mut f_type = None;
5182 let mut f_cmd = None;
5183 let mut f_c_bhvr: Option<Box<CTTLCommonBehaviorData>> = None;
5184 #[cfg(feature = "extra-attrs")]
5185 let mut extra_attrs = std::collections::HashMap::new();
5186 #[cfg(feature = "extra-children")]
5187 let mut extra_children = Vec::new();
5188 #[cfg(feature = "extra-children")]
5189 let mut child_idx: usize = 0;
5190
5191 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
5193 let val = String::from_utf8_lossy(&attr.value);
5194 match attr.key.local_name().as_ref() {
5195 b"type" => {
5196 f_type = val.parse().ok();
5197 }
5198 b"cmd" => {
5199 f_cmd = Some(val.into_owned());
5200 }
5201 #[cfg(feature = "extra-attrs")]
5202 unknown => {
5203 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
5204 extra_attrs.insert(key, val.into_owned());
5205 }
5206 #[cfg(not(feature = "extra-attrs"))]
5207 _ => {}
5208 }
5209 }
5210
5211 if !is_empty {
5213 let mut buf = Vec::new();
5214 loop {
5215 match reader.read_event_into(&mut buf)? {
5216 Event::Start(e) => {
5217 match e.local_name().as_ref() {
5218 b"cBhvr" => {
5219 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
5220 reader, &e, false,
5221 )?));
5222 #[cfg(feature = "extra-children")]
5223 {
5224 child_idx += 1;
5225 }
5226 }
5227 #[cfg(feature = "extra-children")]
5228 _ => {
5229 let elem = RawXmlElement::from_reader(reader, &e)?;
5231 extra_children.push(PositionedNode::new(
5232 child_idx,
5233 RawXmlNode::Element(elem),
5234 ));
5235 child_idx += 1;
5236 }
5237 #[cfg(not(feature = "extra-children"))]
5238 _ => {
5239 skip_element(reader)?;
5241 }
5242 }
5243 }
5244 Event::Empty(e) => {
5245 match e.local_name().as_ref() {
5246 b"cBhvr" => {
5247 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
5248 reader, &e, true,
5249 )?));
5250 #[cfg(feature = "extra-children")]
5251 {
5252 child_idx += 1;
5253 }
5254 }
5255 #[cfg(feature = "extra-children")]
5256 _ => {
5257 let elem = RawXmlElement::from_empty(&e);
5259 extra_children.push(PositionedNode::new(
5260 child_idx,
5261 RawXmlNode::Element(elem),
5262 ));
5263 child_idx += 1;
5264 }
5265 #[cfg(not(feature = "extra-children"))]
5266 _ => {}
5267 }
5268 }
5269 Event::End(_) => break,
5270 Event::Eof => break,
5271 _ => {}
5272 }
5273 buf.clear();
5274 }
5275 }
5276
5277 Ok(Self {
5278 r#type: f_type,
5279 cmd: f_cmd,
5280 c_bhvr: f_c_bhvr.ok_or_else(|| ParseError::MissingAttribute("cBhvr".to_string()))?,
5281 #[cfg(feature = "extra-attrs")]
5282 extra_attrs,
5283 #[cfg(feature = "extra-children")]
5284 extra_children,
5285 })
5286 }
5287}
5288
5289impl FromXml for CTTLSetBehavior {
5290 fn from_xml<R: BufRead>(
5291 reader: &mut Reader<R>,
5292 start_tag: &BytesStart,
5293 is_empty: bool,
5294 ) -> Result<Self, ParseError> {
5295 let mut f_c_bhvr: Option<Box<CTTLCommonBehaviorData>> = None;
5296 let mut f_to = None;
5297 #[cfg(feature = "extra-children")]
5298 let mut extra_children = Vec::new();
5299 #[cfg(feature = "extra-children")]
5300 let mut child_idx: usize = 0;
5301
5302 if !is_empty {
5304 let mut buf = Vec::new();
5305 loop {
5306 match reader.read_event_into(&mut buf)? {
5307 Event::Start(e) => {
5308 match e.local_name().as_ref() {
5309 b"cBhvr" => {
5310 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
5311 reader, &e, false,
5312 )?));
5313 #[cfg(feature = "extra-children")]
5314 {
5315 child_idx += 1;
5316 }
5317 }
5318 b"to" => {
5319 f_to =
5320 Some(Box::new(CTTLAnimVariant::from_xml(reader, &e, false)?));
5321 #[cfg(feature = "extra-children")]
5322 {
5323 child_idx += 1;
5324 }
5325 }
5326 #[cfg(feature = "extra-children")]
5327 _ => {
5328 let elem = RawXmlElement::from_reader(reader, &e)?;
5330 extra_children.push(PositionedNode::new(
5331 child_idx,
5332 RawXmlNode::Element(elem),
5333 ));
5334 child_idx += 1;
5335 }
5336 #[cfg(not(feature = "extra-children"))]
5337 _ => {
5338 skip_element(reader)?;
5340 }
5341 }
5342 }
5343 Event::Empty(e) => {
5344 match e.local_name().as_ref() {
5345 b"cBhvr" => {
5346 f_c_bhvr = Some(Box::new(CTTLCommonBehaviorData::from_xml(
5347 reader, &e, true,
5348 )?));
5349 #[cfg(feature = "extra-children")]
5350 {
5351 child_idx += 1;
5352 }
5353 }
5354 b"to" => {
5355 f_to = Some(Box::new(CTTLAnimVariant::from_xml(reader, &e, true)?));
5356 #[cfg(feature = "extra-children")]
5357 {
5358 child_idx += 1;
5359 }
5360 }
5361 #[cfg(feature = "extra-children")]
5362 _ => {
5363 let elem = RawXmlElement::from_empty(&e);
5365 extra_children.push(PositionedNode::new(
5366 child_idx,
5367 RawXmlNode::Element(elem),
5368 ));
5369 child_idx += 1;
5370 }
5371 #[cfg(not(feature = "extra-children"))]
5372 _ => {}
5373 }
5374 }
5375 Event::End(_) => break,
5376 Event::Eof => break,
5377 _ => {}
5378 }
5379 buf.clear();
5380 }
5381 }
5382
5383 Ok(Self {
5384 c_bhvr: f_c_bhvr.ok_or_else(|| ParseError::MissingAttribute("cBhvr".to_string()))?,
5385 to: f_to,
5386 #[cfg(feature = "extra-children")]
5387 extra_children,
5388 })
5389 }
5390}
5391
5392impl FromXml for CTTLCommonMediaNodeData {
5393 fn from_xml<R: BufRead>(
5394 reader: &mut Reader<R>,
5395 start_tag: &BytesStart,
5396 is_empty: bool,
5397 ) -> Result<Self, ParseError> {
5398 let mut f_vol = None;
5399 let mut f_mute = None;
5400 let mut f_num_sld = None;
5401 let mut f_show_when_stopped = None;
5402 let mut f_c_tn: Option<Box<CTTLCommonTimeNodeData>> = None;
5403 let mut f_tgt_el: Option<Box<CTTLTimeTargetElement>> = None;
5404 #[cfg(feature = "extra-attrs")]
5405 let mut extra_attrs = std::collections::HashMap::new();
5406 #[cfg(feature = "extra-children")]
5407 let mut extra_children = Vec::new();
5408 #[cfg(feature = "extra-children")]
5409 let mut child_idx: usize = 0;
5410
5411 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
5413 let val = String::from_utf8_lossy(&attr.value);
5414 match attr.key.local_name().as_ref() {
5415 b"vol" => {
5416 f_vol = val.parse().ok();
5417 }
5418 b"mute" => {
5419 f_mute = Some(val == "true" || val == "1");
5420 }
5421 b"numSld" => {
5422 f_num_sld = val.parse().ok();
5423 }
5424 b"showWhenStopped" => {
5425 f_show_when_stopped = Some(val == "true" || val == "1");
5426 }
5427 #[cfg(feature = "extra-attrs")]
5428 unknown => {
5429 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
5430 extra_attrs.insert(key, val.into_owned());
5431 }
5432 #[cfg(not(feature = "extra-attrs"))]
5433 _ => {}
5434 }
5435 }
5436
5437 if !is_empty {
5439 let mut buf = Vec::new();
5440 loop {
5441 match reader.read_event_into(&mut buf)? {
5442 Event::Start(e) => {
5443 match e.local_name().as_ref() {
5444 b"cTn" => {
5445 f_c_tn = Some(Box::new(CTTLCommonTimeNodeData::from_xml(
5446 reader, &e, false,
5447 )?));
5448 #[cfg(feature = "extra-children")]
5449 {
5450 child_idx += 1;
5451 }
5452 }
5453 b"tgtEl" => {
5454 f_tgt_el = Some(Box::new(CTTLTimeTargetElement::from_xml(
5455 reader, &e, false,
5456 )?));
5457 #[cfg(feature = "extra-children")]
5458 {
5459 child_idx += 1;
5460 }
5461 }
5462 #[cfg(feature = "extra-children")]
5463 _ => {
5464 let elem = RawXmlElement::from_reader(reader, &e)?;
5466 extra_children.push(PositionedNode::new(
5467 child_idx,
5468 RawXmlNode::Element(elem),
5469 ));
5470 child_idx += 1;
5471 }
5472 #[cfg(not(feature = "extra-children"))]
5473 _ => {
5474 skip_element(reader)?;
5476 }
5477 }
5478 }
5479 Event::Empty(e) => {
5480 match e.local_name().as_ref() {
5481 b"cTn" => {
5482 f_c_tn = Some(Box::new(CTTLCommonTimeNodeData::from_xml(
5483 reader, &e, true,
5484 )?));
5485 #[cfg(feature = "extra-children")]
5486 {
5487 child_idx += 1;
5488 }
5489 }
5490 b"tgtEl" => {
5491 f_tgt_el = Some(Box::new(CTTLTimeTargetElement::from_xml(
5492 reader, &e, true,
5493 )?));
5494 #[cfg(feature = "extra-children")]
5495 {
5496 child_idx += 1;
5497 }
5498 }
5499 #[cfg(feature = "extra-children")]
5500 _ => {
5501 let elem = RawXmlElement::from_empty(&e);
5503 extra_children.push(PositionedNode::new(
5504 child_idx,
5505 RawXmlNode::Element(elem),
5506 ));
5507 child_idx += 1;
5508 }
5509 #[cfg(not(feature = "extra-children"))]
5510 _ => {}
5511 }
5512 }
5513 Event::End(_) => break,
5514 Event::Eof => break,
5515 _ => {}
5516 }
5517 buf.clear();
5518 }
5519 }
5520
5521 Ok(Self {
5522 vol: f_vol,
5523 mute: f_mute,
5524 num_sld: f_num_sld,
5525 show_when_stopped: f_show_when_stopped,
5526 c_tn: f_c_tn.ok_or_else(|| ParseError::MissingAttribute("cTn".to_string()))?,
5527 tgt_el: f_tgt_el.ok_or_else(|| ParseError::MissingAttribute("tgtEl".to_string()))?,
5528 #[cfg(feature = "extra-attrs")]
5529 extra_attrs,
5530 #[cfg(feature = "extra-children")]
5531 extra_children,
5532 })
5533 }
5534}
5535
5536impl FromXml for CTTLMediaNodeAudio {
5537 fn from_xml<R: BufRead>(
5538 reader: &mut Reader<R>,
5539 start_tag: &BytesStart,
5540 is_empty: bool,
5541 ) -> Result<Self, ParseError> {
5542 let mut f_is_narration = None;
5543 let mut f_c_media_node: Option<Box<CTTLCommonMediaNodeData>> = None;
5544 #[cfg(feature = "extra-attrs")]
5545 let mut extra_attrs = std::collections::HashMap::new();
5546 #[cfg(feature = "extra-children")]
5547 let mut extra_children = Vec::new();
5548 #[cfg(feature = "extra-children")]
5549 let mut child_idx: usize = 0;
5550
5551 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
5553 let val = String::from_utf8_lossy(&attr.value);
5554 match attr.key.local_name().as_ref() {
5555 b"isNarration" => {
5556 f_is_narration = Some(val == "true" || val == "1");
5557 }
5558 #[cfg(feature = "extra-attrs")]
5559 unknown => {
5560 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
5561 extra_attrs.insert(key, val.into_owned());
5562 }
5563 #[cfg(not(feature = "extra-attrs"))]
5564 _ => {}
5565 }
5566 }
5567
5568 if !is_empty {
5570 let mut buf = Vec::new();
5571 loop {
5572 match reader.read_event_into(&mut buf)? {
5573 Event::Start(e) => {
5574 match e.local_name().as_ref() {
5575 b"cMediaNode" => {
5576 f_c_media_node = Some(Box::new(CTTLCommonMediaNodeData::from_xml(
5577 reader, &e, false,
5578 )?));
5579 #[cfg(feature = "extra-children")]
5580 {
5581 child_idx += 1;
5582 }
5583 }
5584 #[cfg(feature = "extra-children")]
5585 _ => {
5586 let elem = RawXmlElement::from_reader(reader, &e)?;
5588 extra_children.push(PositionedNode::new(
5589 child_idx,
5590 RawXmlNode::Element(elem),
5591 ));
5592 child_idx += 1;
5593 }
5594 #[cfg(not(feature = "extra-children"))]
5595 _ => {
5596 skip_element(reader)?;
5598 }
5599 }
5600 }
5601 Event::Empty(e) => {
5602 match e.local_name().as_ref() {
5603 b"cMediaNode" => {
5604 f_c_media_node = Some(Box::new(CTTLCommonMediaNodeData::from_xml(
5605 reader, &e, true,
5606 )?));
5607 #[cfg(feature = "extra-children")]
5608 {
5609 child_idx += 1;
5610 }
5611 }
5612 #[cfg(feature = "extra-children")]
5613 _ => {
5614 let elem = RawXmlElement::from_empty(&e);
5616 extra_children.push(PositionedNode::new(
5617 child_idx,
5618 RawXmlNode::Element(elem),
5619 ));
5620 child_idx += 1;
5621 }
5622 #[cfg(not(feature = "extra-children"))]
5623 _ => {}
5624 }
5625 }
5626 Event::End(_) => break,
5627 Event::Eof => break,
5628 _ => {}
5629 }
5630 buf.clear();
5631 }
5632 }
5633
5634 Ok(Self {
5635 is_narration: f_is_narration,
5636 c_media_node: f_c_media_node
5637 .ok_or_else(|| ParseError::MissingAttribute("cMediaNode".to_string()))?,
5638 #[cfg(feature = "extra-attrs")]
5639 extra_attrs,
5640 #[cfg(feature = "extra-children")]
5641 extra_children,
5642 })
5643 }
5644}
5645
5646impl FromXml for CTTLMediaNodeVideo {
5647 fn from_xml<R: BufRead>(
5648 reader: &mut Reader<R>,
5649 start_tag: &BytesStart,
5650 is_empty: bool,
5651 ) -> Result<Self, ParseError> {
5652 let mut f_full_scrn = None;
5653 let mut f_c_media_node: Option<Box<CTTLCommonMediaNodeData>> = None;
5654 #[cfg(feature = "extra-attrs")]
5655 let mut extra_attrs = std::collections::HashMap::new();
5656 #[cfg(feature = "extra-children")]
5657 let mut extra_children = Vec::new();
5658 #[cfg(feature = "extra-children")]
5659 let mut child_idx: usize = 0;
5660
5661 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
5663 let val = String::from_utf8_lossy(&attr.value);
5664 match attr.key.local_name().as_ref() {
5665 b"fullScrn" => {
5666 f_full_scrn = Some(val == "true" || val == "1");
5667 }
5668 #[cfg(feature = "extra-attrs")]
5669 unknown => {
5670 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
5671 extra_attrs.insert(key, val.into_owned());
5672 }
5673 #[cfg(not(feature = "extra-attrs"))]
5674 _ => {}
5675 }
5676 }
5677
5678 if !is_empty {
5680 let mut buf = Vec::new();
5681 loop {
5682 match reader.read_event_into(&mut buf)? {
5683 Event::Start(e) => {
5684 match e.local_name().as_ref() {
5685 b"cMediaNode" => {
5686 f_c_media_node = Some(Box::new(CTTLCommonMediaNodeData::from_xml(
5687 reader, &e, false,
5688 )?));
5689 #[cfg(feature = "extra-children")]
5690 {
5691 child_idx += 1;
5692 }
5693 }
5694 #[cfg(feature = "extra-children")]
5695 _ => {
5696 let elem = RawXmlElement::from_reader(reader, &e)?;
5698 extra_children.push(PositionedNode::new(
5699 child_idx,
5700 RawXmlNode::Element(elem),
5701 ));
5702 child_idx += 1;
5703 }
5704 #[cfg(not(feature = "extra-children"))]
5705 _ => {
5706 skip_element(reader)?;
5708 }
5709 }
5710 }
5711 Event::Empty(e) => {
5712 match e.local_name().as_ref() {
5713 b"cMediaNode" => {
5714 f_c_media_node = Some(Box::new(CTTLCommonMediaNodeData::from_xml(
5715 reader, &e, true,
5716 )?));
5717 #[cfg(feature = "extra-children")]
5718 {
5719 child_idx += 1;
5720 }
5721 }
5722 #[cfg(feature = "extra-children")]
5723 _ => {
5724 let elem = RawXmlElement::from_empty(&e);
5726 extra_children.push(PositionedNode::new(
5727 child_idx,
5728 RawXmlNode::Element(elem),
5729 ));
5730 child_idx += 1;
5731 }
5732 #[cfg(not(feature = "extra-children"))]
5733 _ => {}
5734 }
5735 }
5736 Event::End(_) => break,
5737 Event::Eof => break,
5738 _ => {}
5739 }
5740 buf.clear();
5741 }
5742 }
5743
5744 Ok(Self {
5745 full_scrn: f_full_scrn,
5746 c_media_node: f_c_media_node
5747 .ok_or_else(|| ParseError::MissingAttribute("cMediaNode".to_string()))?,
5748 #[cfg(feature = "extra-attrs")]
5749 extra_attrs,
5750 #[cfg(feature = "extra-children")]
5751 extra_children,
5752 })
5753 }
5754}
5755
5756impl FromXml for PAGTLBuild {
5757 fn from_xml<R: BufRead>(
5758 reader: &mut Reader<R>,
5759 start_tag: &BytesStart,
5760 is_empty: bool,
5761 ) -> Result<Self, ParseError> {
5762 let mut f_spid: Option<ooxml_dml::types::STDrawingElementId> = None;
5763 let mut f_grp_id: Option<u32> = None;
5764 let mut f_ui_expand = None;
5765 #[cfg(feature = "extra-attrs")]
5766 let mut extra_attrs = std::collections::HashMap::new();
5767
5768 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
5770 let val = String::from_utf8_lossy(&attr.value);
5771 match attr.key.local_name().as_ref() {
5772 b"spid" => {
5773 f_spid = val.parse().ok();
5774 }
5775 b"grpId" => {
5776 f_grp_id = val.parse().ok();
5777 }
5778 b"uiExpand" => {
5779 f_ui_expand = Some(val == "true" || val == "1");
5780 }
5781 #[cfg(feature = "extra-attrs")]
5782 unknown => {
5783 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
5784 extra_attrs.insert(key, val.into_owned());
5785 }
5786 #[cfg(not(feature = "extra-attrs"))]
5787 _ => {}
5788 }
5789 }
5790
5791 if !is_empty {
5792 let mut buf = Vec::new();
5793 loop {
5794 match reader.read_event_into(&mut buf)? {
5795 Event::End(_) => break,
5796 Event::Eof => break,
5797 _ => {}
5798 }
5799 buf.clear();
5800 }
5801 }
5802
5803 Ok(Self {
5804 spid: f_spid.ok_or_else(|| ParseError::MissingAttribute("spid".to_string()))?,
5805 grp_id: f_grp_id.ok_or_else(|| ParseError::MissingAttribute("grpId".to_string()))?,
5806 ui_expand: f_ui_expand,
5807 #[cfg(feature = "extra-attrs")]
5808 extra_attrs,
5809 })
5810 }
5811}
5812
5813impl FromXml for CTTLTemplate {
5814 fn from_xml<R: BufRead>(
5815 reader: &mut Reader<R>,
5816 start_tag: &BytesStart,
5817 is_empty: bool,
5818 ) -> Result<Self, ParseError> {
5819 let mut f_lvl = None;
5820 let mut f_tn_lst: Option<Box<CTTimeNodeList>> = None;
5821 #[cfg(feature = "extra-attrs")]
5822 let mut extra_attrs = std::collections::HashMap::new();
5823 #[cfg(feature = "extra-children")]
5824 let mut extra_children = Vec::new();
5825 #[cfg(feature = "extra-children")]
5826 let mut child_idx: usize = 0;
5827
5828 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
5830 let val = String::from_utf8_lossy(&attr.value);
5831 match attr.key.local_name().as_ref() {
5832 b"lvl" => {
5833 f_lvl = val.parse().ok();
5834 }
5835 #[cfg(feature = "extra-attrs")]
5836 unknown => {
5837 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
5838 extra_attrs.insert(key, val.into_owned());
5839 }
5840 #[cfg(not(feature = "extra-attrs"))]
5841 _ => {}
5842 }
5843 }
5844
5845 if !is_empty {
5847 let mut buf = Vec::new();
5848 loop {
5849 match reader.read_event_into(&mut buf)? {
5850 Event::Start(e) => {
5851 match e.local_name().as_ref() {
5852 b"tnLst" => {
5853 f_tn_lst =
5854 Some(Box::new(CTTimeNodeList::from_xml(reader, &e, false)?));
5855 #[cfg(feature = "extra-children")]
5856 {
5857 child_idx += 1;
5858 }
5859 }
5860 #[cfg(feature = "extra-children")]
5861 _ => {
5862 let elem = RawXmlElement::from_reader(reader, &e)?;
5864 extra_children.push(PositionedNode::new(
5865 child_idx,
5866 RawXmlNode::Element(elem),
5867 ));
5868 child_idx += 1;
5869 }
5870 #[cfg(not(feature = "extra-children"))]
5871 _ => {
5872 skip_element(reader)?;
5874 }
5875 }
5876 }
5877 Event::Empty(e) => {
5878 match e.local_name().as_ref() {
5879 b"tnLst" => {
5880 f_tn_lst =
5881 Some(Box::new(CTTimeNodeList::from_xml(reader, &e, true)?));
5882 #[cfg(feature = "extra-children")]
5883 {
5884 child_idx += 1;
5885 }
5886 }
5887 #[cfg(feature = "extra-children")]
5888 _ => {
5889 let elem = RawXmlElement::from_empty(&e);
5891 extra_children.push(PositionedNode::new(
5892 child_idx,
5893 RawXmlNode::Element(elem),
5894 ));
5895 child_idx += 1;
5896 }
5897 #[cfg(not(feature = "extra-children"))]
5898 _ => {}
5899 }
5900 }
5901 Event::End(_) => break,
5902 Event::Eof => break,
5903 _ => {}
5904 }
5905 buf.clear();
5906 }
5907 }
5908
5909 Ok(Self {
5910 lvl: f_lvl,
5911 tn_lst: f_tn_lst.ok_or_else(|| ParseError::MissingAttribute("tnLst".to_string()))?,
5912 #[cfg(feature = "extra-attrs")]
5913 extra_attrs,
5914 #[cfg(feature = "extra-children")]
5915 extra_children,
5916 })
5917 }
5918}
5919
5920impl FromXml for CTTLTemplateList {
5921 fn from_xml<R: BufRead>(
5922 reader: &mut Reader<R>,
5923 start_tag: &BytesStart,
5924 is_empty: bool,
5925 ) -> Result<Self, ParseError> {
5926 let mut f_tmpl = Vec::new();
5927 #[cfg(feature = "extra-children")]
5928 let mut extra_children = Vec::new();
5929 #[cfg(feature = "extra-children")]
5930 let mut child_idx: usize = 0;
5931
5932 if !is_empty {
5934 let mut buf = Vec::new();
5935 loop {
5936 match reader.read_event_into(&mut buf)? {
5937 Event::Start(e) => {
5938 match e.local_name().as_ref() {
5939 b"tmpl" => {
5940 f_tmpl.push(CTTLTemplate::from_xml(reader, &e, false)?);
5941 #[cfg(feature = "extra-children")]
5942 {
5943 child_idx += 1;
5944 }
5945 }
5946 #[cfg(feature = "extra-children")]
5947 _ => {
5948 let elem = RawXmlElement::from_reader(reader, &e)?;
5950 extra_children.push(PositionedNode::new(
5951 child_idx,
5952 RawXmlNode::Element(elem),
5953 ));
5954 child_idx += 1;
5955 }
5956 #[cfg(not(feature = "extra-children"))]
5957 _ => {
5958 skip_element(reader)?;
5960 }
5961 }
5962 }
5963 Event::Empty(e) => {
5964 match e.local_name().as_ref() {
5965 b"tmpl" => {
5966 f_tmpl.push(CTTLTemplate::from_xml(reader, &e, true)?);
5967 #[cfg(feature = "extra-children")]
5968 {
5969 child_idx += 1;
5970 }
5971 }
5972 #[cfg(feature = "extra-children")]
5973 _ => {
5974 let elem = RawXmlElement::from_empty(&e);
5976 extra_children.push(PositionedNode::new(
5977 child_idx,
5978 RawXmlNode::Element(elem),
5979 ));
5980 child_idx += 1;
5981 }
5982 #[cfg(not(feature = "extra-children"))]
5983 _ => {}
5984 }
5985 }
5986 Event::End(_) => break,
5987 Event::Eof => break,
5988 _ => {}
5989 }
5990 buf.clear();
5991 }
5992 }
5993
5994 Ok(Self {
5995 tmpl: f_tmpl,
5996 #[cfg(feature = "extra-children")]
5997 extra_children,
5998 })
5999 }
6000}
6001
6002impl FromXml for CTTLBuildParagraph {
6003 fn from_xml<R: BufRead>(
6004 reader: &mut Reader<R>,
6005 start_tag: &BytesStart,
6006 is_empty: bool,
6007 ) -> Result<Self, ParseError> {
6008 let mut f_spid: Option<ooxml_dml::types::STDrawingElementId> = None;
6009 let mut f_grp_id: Option<u32> = None;
6010 let mut f_ui_expand = None;
6011 let mut f_build = None;
6012 let mut f_bld_lvl = None;
6013 let mut f_anim_bg = None;
6014 let mut f_auto_update_anim_bg = None;
6015 let mut f_rev = None;
6016 let mut f_adv_auto = None;
6017 let mut f_tmpl_lst = None;
6018 #[cfg(feature = "extra-attrs")]
6019 let mut extra_attrs = std::collections::HashMap::new();
6020 #[cfg(feature = "extra-children")]
6021 let mut extra_children = Vec::new();
6022 #[cfg(feature = "extra-children")]
6023 let mut child_idx: usize = 0;
6024
6025 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
6027 let val = String::from_utf8_lossy(&attr.value);
6028 match attr.key.local_name().as_ref() {
6029 b"spid" => {
6030 f_spid = val.parse().ok();
6031 }
6032 b"grpId" => {
6033 f_grp_id = val.parse().ok();
6034 }
6035 b"uiExpand" => {
6036 f_ui_expand = Some(val == "true" || val == "1");
6037 }
6038 b"build" => {
6039 f_build = val.parse().ok();
6040 }
6041 b"bldLvl" => {
6042 f_bld_lvl = val.parse().ok();
6043 }
6044 b"animBg" => {
6045 f_anim_bg = Some(val == "true" || val == "1");
6046 }
6047 b"autoUpdateAnimBg" => {
6048 f_auto_update_anim_bg = Some(val == "true" || val == "1");
6049 }
6050 b"rev" => {
6051 f_rev = Some(val == "true" || val == "1");
6052 }
6053 b"advAuto" => {
6054 f_adv_auto = Some(val.into_owned());
6055 }
6056 #[cfg(feature = "extra-attrs")]
6057 unknown => {
6058 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
6059 extra_attrs.insert(key, val.into_owned());
6060 }
6061 #[cfg(not(feature = "extra-attrs"))]
6062 _ => {}
6063 }
6064 }
6065
6066 if !is_empty {
6068 let mut buf = Vec::new();
6069 loop {
6070 match reader.read_event_into(&mut buf)? {
6071 Event::Start(e) => {
6072 match e.local_name().as_ref() {
6073 b"tmplLst" => {
6074 f_tmpl_lst =
6075 Some(Box::new(CTTLTemplateList::from_xml(reader, &e, false)?));
6076 #[cfg(feature = "extra-children")]
6077 {
6078 child_idx += 1;
6079 }
6080 }
6081 #[cfg(feature = "extra-children")]
6082 _ => {
6083 let elem = RawXmlElement::from_reader(reader, &e)?;
6085 extra_children.push(PositionedNode::new(
6086 child_idx,
6087 RawXmlNode::Element(elem),
6088 ));
6089 child_idx += 1;
6090 }
6091 #[cfg(not(feature = "extra-children"))]
6092 _ => {
6093 skip_element(reader)?;
6095 }
6096 }
6097 }
6098 Event::Empty(e) => {
6099 match e.local_name().as_ref() {
6100 b"tmplLst" => {
6101 f_tmpl_lst =
6102 Some(Box::new(CTTLTemplateList::from_xml(reader, &e, true)?));
6103 #[cfg(feature = "extra-children")]
6104 {
6105 child_idx += 1;
6106 }
6107 }
6108 #[cfg(feature = "extra-children")]
6109 _ => {
6110 let elem = RawXmlElement::from_empty(&e);
6112 extra_children.push(PositionedNode::new(
6113 child_idx,
6114 RawXmlNode::Element(elem),
6115 ));
6116 child_idx += 1;
6117 }
6118 #[cfg(not(feature = "extra-children"))]
6119 _ => {}
6120 }
6121 }
6122 Event::End(_) => break,
6123 Event::Eof => break,
6124 _ => {}
6125 }
6126 buf.clear();
6127 }
6128 }
6129
6130 Ok(Self {
6131 spid: f_spid.ok_or_else(|| ParseError::MissingAttribute("spid".to_string()))?,
6132 grp_id: f_grp_id.ok_or_else(|| ParseError::MissingAttribute("grpId".to_string()))?,
6133 ui_expand: f_ui_expand,
6134 build: f_build,
6135 bld_lvl: f_bld_lvl,
6136 anim_bg: f_anim_bg,
6137 auto_update_anim_bg: f_auto_update_anim_bg,
6138 rev: f_rev,
6139 adv_auto: f_adv_auto,
6140 tmpl_lst: f_tmpl_lst,
6141 #[cfg(feature = "extra-attrs")]
6142 extra_attrs,
6143 #[cfg(feature = "extra-children")]
6144 extra_children,
6145 })
6146 }
6147}
6148
6149impl FromXml for CTTLBuildDiagram {
6150 fn from_xml<R: BufRead>(
6151 reader: &mut Reader<R>,
6152 start_tag: &BytesStart,
6153 is_empty: bool,
6154 ) -> Result<Self, ParseError> {
6155 let mut f_spid: Option<ooxml_dml::types::STDrawingElementId> = None;
6156 let mut f_grp_id: Option<u32> = None;
6157 let mut f_ui_expand = None;
6158 let mut f_bld = None;
6159 #[cfg(feature = "extra-attrs")]
6160 let mut extra_attrs = std::collections::HashMap::new();
6161
6162 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
6164 let val = String::from_utf8_lossy(&attr.value);
6165 match attr.key.local_name().as_ref() {
6166 b"spid" => {
6167 f_spid = val.parse().ok();
6168 }
6169 b"grpId" => {
6170 f_grp_id = val.parse().ok();
6171 }
6172 b"uiExpand" => {
6173 f_ui_expand = Some(val == "true" || val == "1");
6174 }
6175 b"bld" => {
6176 f_bld = val.parse().ok();
6177 }
6178 #[cfg(feature = "extra-attrs")]
6179 unknown => {
6180 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
6181 extra_attrs.insert(key, val.into_owned());
6182 }
6183 #[cfg(not(feature = "extra-attrs"))]
6184 _ => {}
6185 }
6186 }
6187
6188 if !is_empty {
6189 let mut buf = Vec::new();
6190 loop {
6191 match reader.read_event_into(&mut buf)? {
6192 Event::End(_) => break,
6193 Event::Eof => break,
6194 _ => {}
6195 }
6196 buf.clear();
6197 }
6198 }
6199
6200 Ok(Self {
6201 spid: f_spid.ok_or_else(|| ParseError::MissingAttribute("spid".to_string()))?,
6202 grp_id: f_grp_id.ok_or_else(|| ParseError::MissingAttribute("grpId".to_string()))?,
6203 ui_expand: f_ui_expand,
6204 bld: f_bld,
6205 #[cfg(feature = "extra-attrs")]
6206 extra_attrs,
6207 })
6208 }
6209}
6210
6211impl FromXml for CTTLOleBuildChart {
6212 fn from_xml<R: BufRead>(
6213 reader: &mut Reader<R>,
6214 start_tag: &BytesStart,
6215 is_empty: bool,
6216 ) -> Result<Self, ParseError> {
6217 let mut f_spid: Option<ooxml_dml::types::STDrawingElementId> = None;
6218 let mut f_grp_id: Option<u32> = None;
6219 let mut f_ui_expand = None;
6220 let mut f_bld = None;
6221 let mut f_anim_bg = None;
6222 #[cfg(feature = "extra-attrs")]
6223 let mut extra_attrs = std::collections::HashMap::new();
6224
6225 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
6227 let val = String::from_utf8_lossy(&attr.value);
6228 match attr.key.local_name().as_ref() {
6229 b"spid" => {
6230 f_spid = val.parse().ok();
6231 }
6232 b"grpId" => {
6233 f_grp_id = val.parse().ok();
6234 }
6235 b"uiExpand" => {
6236 f_ui_expand = Some(val == "true" || val == "1");
6237 }
6238 b"bld" => {
6239 f_bld = val.parse().ok();
6240 }
6241 b"animBg" => {
6242 f_anim_bg = Some(val == "true" || val == "1");
6243 }
6244 #[cfg(feature = "extra-attrs")]
6245 unknown => {
6246 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
6247 extra_attrs.insert(key, val.into_owned());
6248 }
6249 #[cfg(not(feature = "extra-attrs"))]
6250 _ => {}
6251 }
6252 }
6253
6254 if !is_empty {
6255 let mut buf = Vec::new();
6256 loop {
6257 match reader.read_event_into(&mut buf)? {
6258 Event::End(_) => break,
6259 Event::Eof => break,
6260 _ => {}
6261 }
6262 buf.clear();
6263 }
6264 }
6265
6266 Ok(Self {
6267 spid: f_spid.ok_or_else(|| ParseError::MissingAttribute("spid".to_string()))?,
6268 grp_id: f_grp_id.ok_or_else(|| ParseError::MissingAttribute("grpId".to_string()))?,
6269 ui_expand: f_ui_expand,
6270 bld: f_bld,
6271 anim_bg: f_anim_bg,
6272 #[cfg(feature = "extra-attrs")]
6273 extra_attrs,
6274 })
6275 }
6276}
6277
6278impl FromXml for CTTLGraphicalObjectBuild {
6279 fn from_xml<R: BufRead>(
6280 reader: &mut Reader<R>,
6281 start_tag: &BytesStart,
6282 is_empty: bool,
6283 ) -> Result<Self, ParseError> {
6284 let mut f_spid: Option<ooxml_dml::types::STDrawingElementId> = None;
6285 let mut f_grp_id: Option<u32> = None;
6286 let mut f_ui_expand = None;
6287 let mut f_bld_as_one = None;
6288 let mut f_bld_sub = None;
6289 #[cfg(feature = "extra-attrs")]
6290 let mut extra_attrs = std::collections::HashMap::new();
6291 #[cfg(feature = "extra-children")]
6292 let mut extra_children = Vec::new();
6293 #[cfg(feature = "extra-children")]
6294 let mut child_idx: usize = 0;
6295
6296 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
6298 let val = String::from_utf8_lossy(&attr.value);
6299 match attr.key.local_name().as_ref() {
6300 b"spid" => {
6301 f_spid = val.parse().ok();
6302 }
6303 b"grpId" => {
6304 f_grp_id = val.parse().ok();
6305 }
6306 b"uiExpand" => {
6307 f_ui_expand = Some(val == "true" || val == "1");
6308 }
6309 #[cfg(feature = "extra-attrs")]
6310 unknown => {
6311 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
6312 extra_attrs.insert(key, val.into_owned());
6313 }
6314 #[cfg(not(feature = "extra-attrs"))]
6315 _ => {}
6316 }
6317 }
6318
6319 if !is_empty {
6321 let mut buf = Vec::new();
6322 loop {
6323 match reader.read_event_into(&mut buf)? {
6324 Event::Start(e) => {
6325 match e.local_name().as_ref() {
6326 b"bldAsOne" => {
6327 f_bld_as_one =
6328 Some(Box::new(CTEmpty::from_xml(reader, &e, false)?));
6329 #[cfg(feature = "extra-children")]
6330 {
6331 child_idx += 1;
6332 }
6333 }
6334 b"bldSub" => {
6335 f_bld_sub = Some(Box::new(ooxml_dml::types::CTAnimationGraphicalObjectBuildProperties::from_xml(reader, &e, false)?));
6336 #[cfg(feature = "extra-children")]
6337 {
6338 child_idx += 1;
6339 }
6340 }
6341 #[cfg(feature = "extra-children")]
6342 _ => {
6343 let elem = RawXmlElement::from_reader(reader, &e)?;
6345 extra_children.push(PositionedNode::new(
6346 child_idx,
6347 RawXmlNode::Element(elem),
6348 ));
6349 child_idx += 1;
6350 }
6351 #[cfg(not(feature = "extra-children"))]
6352 _ => {
6353 skip_element(reader)?;
6355 }
6356 }
6357 }
6358 Event::Empty(e) => {
6359 match e.local_name().as_ref() {
6360 b"bldAsOne" => {
6361 f_bld_as_one = Some(Box::new(CTEmpty::from_xml(reader, &e, true)?));
6362 #[cfg(feature = "extra-children")]
6363 {
6364 child_idx += 1;
6365 }
6366 }
6367 b"bldSub" => {
6368 f_bld_sub = Some(Box::new(ooxml_dml::types::CTAnimationGraphicalObjectBuildProperties::from_xml(reader, &e, true)?));
6369 #[cfg(feature = "extra-children")]
6370 {
6371 child_idx += 1;
6372 }
6373 }
6374 #[cfg(feature = "extra-children")]
6375 _ => {
6376 let elem = RawXmlElement::from_empty(&e);
6378 extra_children.push(PositionedNode::new(
6379 child_idx,
6380 RawXmlNode::Element(elem),
6381 ));
6382 child_idx += 1;
6383 }
6384 #[cfg(not(feature = "extra-children"))]
6385 _ => {}
6386 }
6387 }
6388 Event::End(_) => break,
6389 Event::Eof => break,
6390 _ => {}
6391 }
6392 buf.clear();
6393 }
6394 }
6395
6396 Ok(Self {
6397 spid: f_spid.ok_or_else(|| ParseError::MissingAttribute("spid".to_string()))?,
6398 grp_id: f_grp_id.ok_or_else(|| ParseError::MissingAttribute("grpId".to_string()))?,
6399 ui_expand: f_ui_expand,
6400 bld_as_one: f_bld_as_one,
6401 bld_sub: f_bld_sub,
6402 #[cfg(feature = "extra-attrs")]
6403 extra_attrs,
6404 #[cfg(feature = "extra-children")]
6405 extra_children,
6406 })
6407 }
6408}
6409
6410impl FromXml for CTBuildList {
6411 fn from_xml<R: BufRead>(
6412 reader: &mut Reader<R>,
6413 start_tag: &BytesStart,
6414 is_empty: bool,
6415 ) -> Result<Self, ParseError> {
6416 let mut f_bld_p = Vec::new();
6417 let mut f_bld_dgm = Vec::new();
6418 let mut f_bld_ole_chart = Vec::new();
6419 let mut f_bld_graphic = Vec::new();
6420 #[cfg(feature = "extra-children")]
6421 let mut extra_children = Vec::new();
6422 #[cfg(feature = "extra-children")]
6423 let mut child_idx: usize = 0;
6424
6425 if !is_empty {
6427 let mut buf = Vec::new();
6428 loop {
6429 match reader.read_event_into(&mut buf)? {
6430 Event::Start(e) => {
6431 match e.local_name().as_ref() {
6432 b"bldP" => {
6433 f_bld_p.push(CTTLBuildParagraph::from_xml(reader, &e, false)?);
6434 #[cfg(feature = "extra-children")]
6435 {
6436 child_idx += 1;
6437 }
6438 }
6439 b"bldDgm" => {
6440 f_bld_dgm.push(CTTLBuildDiagram::from_xml(reader, &e, false)?);
6441 #[cfg(feature = "extra-children")]
6442 {
6443 child_idx += 1;
6444 }
6445 }
6446 b"bldOleChart" => {
6447 f_bld_ole_chart
6448 .push(CTTLOleBuildChart::from_xml(reader, &e, false)?);
6449 #[cfg(feature = "extra-children")]
6450 {
6451 child_idx += 1;
6452 }
6453 }
6454 b"bldGraphic" => {
6455 f_bld_graphic
6456 .push(CTTLGraphicalObjectBuild::from_xml(reader, &e, false)?);
6457 #[cfg(feature = "extra-children")]
6458 {
6459 child_idx += 1;
6460 }
6461 }
6462 #[cfg(feature = "extra-children")]
6463 _ => {
6464 let elem = RawXmlElement::from_reader(reader, &e)?;
6466 extra_children.push(PositionedNode::new(
6467 child_idx,
6468 RawXmlNode::Element(elem),
6469 ));
6470 child_idx += 1;
6471 }
6472 #[cfg(not(feature = "extra-children"))]
6473 _ => {
6474 skip_element(reader)?;
6476 }
6477 }
6478 }
6479 Event::Empty(e) => {
6480 match e.local_name().as_ref() {
6481 b"bldP" => {
6482 f_bld_p.push(CTTLBuildParagraph::from_xml(reader, &e, true)?);
6483 #[cfg(feature = "extra-children")]
6484 {
6485 child_idx += 1;
6486 }
6487 }
6488 b"bldDgm" => {
6489 f_bld_dgm.push(CTTLBuildDiagram::from_xml(reader, &e, true)?);
6490 #[cfg(feature = "extra-children")]
6491 {
6492 child_idx += 1;
6493 }
6494 }
6495 b"bldOleChart" => {
6496 f_bld_ole_chart
6497 .push(CTTLOleBuildChart::from_xml(reader, &e, true)?);
6498 #[cfg(feature = "extra-children")]
6499 {
6500 child_idx += 1;
6501 }
6502 }
6503 b"bldGraphic" => {
6504 f_bld_graphic
6505 .push(CTTLGraphicalObjectBuild::from_xml(reader, &e, true)?);
6506 #[cfg(feature = "extra-children")]
6507 {
6508 child_idx += 1;
6509 }
6510 }
6511 #[cfg(feature = "extra-children")]
6512 _ => {
6513 let elem = RawXmlElement::from_empty(&e);
6515 extra_children.push(PositionedNode::new(
6516 child_idx,
6517 RawXmlNode::Element(elem),
6518 ));
6519 child_idx += 1;
6520 }
6521 #[cfg(not(feature = "extra-children"))]
6522 _ => {}
6523 }
6524 }
6525 Event::End(_) => break,
6526 Event::Eof => break,
6527 _ => {}
6528 }
6529 buf.clear();
6530 }
6531 }
6532
6533 Ok(Self {
6534 bld_p: f_bld_p,
6535 bld_dgm: f_bld_dgm,
6536 bld_ole_chart: f_bld_ole_chart,
6537 bld_graphic: f_bld_graphic,
6538 #[cfg(feature = "extra-children")]
6539 extra_children,
6540 })
6541 }
6542}
6543
6544impl FromXml for SlideTiming {
6545 fn from_xml<R: BufRead>(
6546 reader: &mut Reader<R>,
6547 start_tag: &BytesStart,
6548 is_empty: bool,
6549 ) -> Result<Self, ParseError> {
6550 #[cfg(feature = "pml-animations")]
6551 let mut f_tn_lst = None;
6552 #[cfg(feature = "pml-animations")]
6553 let mut f_bld_lst = None;
6554 #[cfg(feature = "pml-extensions")]
6555 let mut f_ext_lst = None;
6556 #[cfg(feature = "extra-children")]
6557 let mut extra_children = Vec::new();
6558 #[cfg(feature = "extra-children")]
6559 let mut child_idx: usize = 0;
6560
6561 if !is_empty {
6563 let mut buf = Vec::new();
6564 loop {
6565 match reader.read_event_into(&mut buf)? {
6566 Event::Start(e) => {
6567 match e.local_name().as_ref() {
6568 #[cfg(feature = "pml-animations")]
6569 b"tnLst" => {
6570 f_tn_lst =
6571 Some(Box::new(CTTimeNodeList::from_xml(reader, &e, false)?));
6572 #[cfg(feature = "extra-children")]
6573 {
6574 child_idx += 1;
6575 }
6576 }
6577 #[cfg(feature = "pml-animations")]
6578 b"bldLst" => {
6579 f_bld_lst =
6580 Some(Box::new(CTBuildList::from_xml(reader, &e, false)?));
6581 #[cfg(feature = "extra-children")]
6582 {
6583 child_idx += 1;
6584 }
6585 }
6586 #[cfg(feature = "pml-extensions")]
6587 b"extLst" => {
6588 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
6589 reader, &e, false,
6590 )?));
6591 #[cfg(feature = "extra-children")]
6592 {
6593 child_idx += 1;
6594 }
6595 }
6596 #[cfg(feature = "extra-children")]
6597 _ => {
6598 let elem = RawXmlElement::from_reader(reader, &e)?;
6600 extra_children.push(PositionedNode::new(
6601 child_idx,
6602 RawXmlNode::Element(elem),
6603 ));
6604 child_idx += 1;
6605 }
6606 #[cfg(not(feature = "extra-children"))]
6607 _ => {
6608 skip_element(reader)?;
6610 }
6611 }
6612 }
6613 Event::Empty(e) => {
6614 match e.local_name().as_ref() {
6615 #[cfg(feature = "pml-animations")]
6616 b"tnLst" => {
6617 f_tn_lst =
6618 Some(Box::new(CTTimeNodeList::from_xml(reader, &e, true)?));
6619 #[cfg(feature = "extra-children")]
6620 {
6621 child_idx += 1;
6622 }
6623 }
6624 #[cfg(feature = "pml-animations")]
6625 b"bldLst" => {
6626 f_bld_lst =
6627 Some(Box::new(CTBuildList::from_xml(reader, &e, true)?));
6628 #[cfg(feature = "extra-children")]
6629 {
6630 child_idx += 1;
6631 }
6632 }
6633 #[cfg(feature = "pml-extensions")]
6634 b"extLst" => {
6635 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
6636 reader, &e, true,
6637 )?));
6638 #[cfg(feature = "extra-children")]
6639 {
6640 child_idx += 1;
6641 }
6642 }
6643 #[cfg(feature = "extra-children")]
6644 _ => {
6645 let elem = RawXmlElement::from_empty(&e);
6647 extra_children.push(PositionedNode::new(
6648 child_idx,
6649 RawXmlNode::Element(elem),
6650 ));
6651 child_idx += 1;
6652 }
6653 #[cfg(not(feature = "extra-children"))]
6654 _ => {}
6655 }
6656 }
6657 Event::End(_) => break,
6658 Event::Eof => break,
6659 _ => {}
6660 }
6661 buf.clear();
6662 }
6663 }
6664
6665 Ok(Self {
6666 #[cfg(feature = "pml-animations")]
6667 tn_lst: f_tn_lst,
6668 #[cfg(feature = "pml-animations")]
6669 bld_lst: f_bld_lst,
6670 #[cfg(feature = "pml-extensions")]
6671 ext_lst: f_ext_lst,
6672 #[cfg(feature = "extra-children")]
6673 extra_children,
6674 })
6675 }
6676}
6677
6678impl FromXml for CTEmpty {
6679 fn from_xml<R: BufRead>(
6680 reader: &mut Reader<R>,
6681 _start: &BytesStart,
6682 is_empty: bool,
6683 ) -> Result<Self, ParseError> {
6684 if !is_empty {
6685 let mut buf = Vec::new();
6686 let mut depth = 1u32;
6687 loop {
6688 match reader.read_event_into(&mut buf)? {
6689 Event::Start(_) => depth += 1,
6690 Event::End(_) => {
6691 depth -= 1;
6692 if depth == 0 {
6693 break;
6694 }
6695 }
6696 Event::Eof => break,
6697 _ => {}
6698 }
6699 buf.clear();
6700 }
6701 }
6702 Ok(Self {})
6703 }
6704}
6705
6706impl FromXml for CTIndexRange {
6707 fn from_xml<R: BufRead>(
6708 reader: &mut Reader<R>,
6709 start_tag: &BytesStart,
6710 is_empty: bool,
6711 ) -> Result<Self, ParseError> {
6712 let mut f_st: Option<STIndex> = None;
6713 let mut f_end: Option<STIndex> = None;
6714 #[cfg(feature = "extra-attrs")]
6715 let mut extra_attrs = std::collections::HashMap::new();
6716
6717 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
6719 let val = String::from_utf8_lossy(&attr.value);
6720 match attr.key.local_name().as_ref() {
6721 b"st" => {
6722 f_st = val.parse().ok();
6723 }
6724 b"end" => {
6725 f_end = val.parse().ok();
6726 }
6727 #[cfg(feature = "extra-attrs")]
6728 unknown => {
6729 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
6730 extra_attrs.insert(key, val.into_owned());
6731 }
6732 #[cfg(not(feature = "extra-attrs"))]
6733 _ => {}
6734 }
6735 }
6736
6737 if !is_empty {
6738 let mut buf = Vec::new();
6739 loop {
6740 match reader.read_event_into(&mut buf)? {
6741 Event::End(_) => break,
6742 Event::Eof => break,
6743 _ => {}
6744 }
6745 buf.clear();
6746 }
6747 }
6748
6749 Ok(Self {
6750 st: f_st.ok_or_else(|| ParseError::MissingAttribute("st".to_string()))?,
6751 end: f_end.ok_or_else(|| ParseError::MissingAttribute("end".to_string()))?,
6752 #[cfg(feature = "extra-attrs")]
6753 extra_attrs,
6754 })
6755 }
6756}
6757
6758impl FromXml for CTSlideRelationshipListEntry {
6759 fn from_xml<R: BufRead>(
6760 reader: &mut Reader<R>,
6761 start_tag: &BytesStart,
6762 is_empty: bool,
6763 ) -> Result<Self, ParseError> {
6764 #[cfg(feature = "extra-children")]
6765 let mut extra_children = Vec::new();
6766 #[cfg(feature = "extra-children")]
6767 let mut child_idx: usize = 0;
6768 if !is_empty {
6769 let mut buf = Vec::new();
6770 loop {
6771 match reader.read_event_into(&mut buf)? {
6772 #[cfg(feature = "extra-children")]
6773 Event::Start(e) => {
6774 let elem = RawXmlElement::from_reader(reader, &e)?;
6775 extra_children
6776 .push(PositionedNode::new(child_idx, RawXmlNode::Element(elem)));
6777 child_idx += 1;
6778 }
6779 #[cfg(not(feature = "extra-children"))]
6780 Event::Start(_) => {
6781 skip_element(reader)?;
6782 }
6783 #[cfg(feature = "extra-children")]
6784 Event::Empty(e) => {
6785 let elem = RawXmlElement::from_empty(&e);
6786 extra_children
6787 .push(PositionedNode::new(child_idx, RawXmlNode::Element(elem)));
6788 child_idx += 1;
6789 }
6790 #[cfg(not(feature = "extra-children"))]
6791 Event::Empty(_) => {}
6792 Event::End(_) => break,
6793 Event::Eof => break,
6794 _ => {}
6795 }
6796 buf.clear();
6797 }
6798 }
6799 Ok(Self {
6800 #[cfg(feature = "extra-children")]
6801 extra_children,
6802 })
6803 }
6804}
6805
6806impl FromXml for CTSlideRelationshipList {
6807 fn from_xml<R: BufRead>(
6808 reader: &mut Reader<R>,
6809 start_tag: &BytesStart,
6810 is_empty: bool,
6811 ) -> Result<Self, ParseError> {
6812 let mut f_sld = Vec::new();
6813 #[cfg(feature = "extra-children")]
6814 let mut extra_children = Vec::new();
6815 #[cfg(feature = "extra-children")]
6816 let mut child_idx: usize = 0;
6817
6818 if !is_empty {
6820 let mut buf = Vec::new();
6821 loop {
6822 match reader.read_event_into(&mut buf)? {
6823 Event::Start(e) => {
6824 match e.local_name().as_ref() {
6825 b"sld" => {
6826 f_sld.push(CTSlideRelationshipListEntry::from_xml(
6827 reader, &e, false,
6828 )?);
6829 #[cfg(feature = "extra-children")]
6830 {
6831 child_idx += 1;
6832 }
6833 }
6834 #[cfg(feature = "extra-children")]
6835 _ => {
6836 let elem = RawXmlElement::from_reader(reader, &e)?;
6838 extra_children.push(PositionedNode::new(
6839 child_idx,
6840 RawXmlNode::Element(elem),
6841 ));
6842 child_idx += 1;
6843 }
6844 #[cfg(not(feature = "extra-children"))]
6845 _ => {
6846 skip_element(reader)?;
6848 }
6849 }
6850 }
6851 Event::Empty(e) => {
6852 match e.local_name().as_ref() {
6853 b"sld" => {
6854 f_sld.push(CTSlideRelationshipListEntry::from_xml(
6855 reader, &e, true,
6856 )?);
6857 #[cfg(feature = "extra-children")]
6858 {
6859 child_idx += 1;
6860 }
6861 }
6862 #[cfg(feature = "extra-children")]
6863 _ => {
6864 let elem = RawXmlElement::from_empty(&e);
6866 extra_children.push(PositionedNode::new(
6867 child_idx,
6868 RawXmlNode::Element(elem),
6869 ));
6870 child_idx += 1;
6871 }
6872 #[cfg(not(feature = "extra-children"))]
6873 _ => {}
6874 }
6875 }
6876 Event::End(_) => break,
6877 Event::Eof => break,
6878 _ => {}
6879 }
6880 buf.clear();
6881 }
6882 }
6883
6884 Ok(Self {
6885 sld: f_sld,
6886 #[cfg(feature = "extra-children")]
6887 extra_children,
6888 })
6889 }
6890}
6891
6892impl FromXml for CTCustomShowId {
6893 fn from_xml<R: BufRead>(
6894 reader: &mut Reader<R>,
6895 start_tag: &BytesStart,
6896 is_empty: bool,
6897 ) -> Result<Self, ParseError> {
6898 let mut f_id: Option<u32> = None;
6899 #[cfg(feature = "extra-attrs")]
6900 let mut extra_attrs = std::collections::HashMap::new();
6901
6902 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
6904 let val = String::from_utf8_lossy(&attr.value);
6905 match attr.key.local_name().as_ref() {
6906 b"id" => {
6907 f_id = val.parse().ok();
6908 }
6909 #[cfg(feature = "extra-attrs")]
6910 unknown => {
6911 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
6912 extra_attrs.insert(key, val.into_owned());
6913 }
6914 #[cfg(not(feature = "extra-attrs"))]
6915 _ => {}
6916 }
6917 }
6918
6919 if !is_empty {
6920 let mut buf = Vec::new();
6921 loop {
6922 match reader.read_event_into(&mut buf)? {
6923 Event::End(_) => break,
6924 Event::Eof => break,
6925 _ => {}
6926 }
6927 buf.clear();
6928 }
6929 }
6930
6931 Ok(Self {
6932 id: f_id.ok_or_else(|| ParseError::MissingAttribute("id".to_string()))?,
6933 #[cfg(feature = "extra-attrs")]
6934 extra_attrs,
6935 })
6936 }
6937}
6938
6939impl FromXml for EGSlideListChoice {
6940 fn from_xml<R: BufRead>(
6941 reader: &mut Reader<R>,
6942 start_tag: &BytesStart,
6943 is_empty: bool,
6944 ) -> Result<Self, ParseError> {
6945 let tag = start_tag.local_name();
6946 match tag.as_ref() {
6947 b"sldAll" => {
6948 let inner = CTEmpty::from_xml(reader, start_tag, is_empty)?;
6949 Ok(Self::SldAll(Box::new(inner)))
6950 }
6951 b"sldRg" => {
6952 let inner = CTIndexRange::from_xml(reader, start_tag, is_empty)?;
6953 Ok(Self::SldRg(Box::new(inner)))
6954 }
6955 b"custShow" => {
6956 let inner = CTCustomShowId::from_xml(reader, start_tag, is_empty)?;
6957 Ok(Self::CustShow(Box::new(inner)))
6958 }
6959 _ => Err(ParseError::UnexpectedElement(
6960 String::from_utf8_lossy(start_tag.name().as_ref()).into_owned(),
6961 )),
6962 }
6963 }
6964}
6965
6966impl FromXml for CTCustomerData {
6967 fn from_xml<R: BufRead>(
6968 reader: &mut Reader<R>,
6969 start_tag: &BytesStart,
6970 is_empty: bool,
6971 ) -> Result<Self, ParseError> {
6972 #[cfg(feature = "extra-children")]
6973 let mut extra_children = Vec::new();
6974 #[cfg(feature = "extra-children")]
6975 let mut child_idx: usize = 0;
6976 if !is_empty {
6977 let mut buf = Vec::new();
6978 loop {
6979 match reader.read_event_into(&mut buf)? {
6980 #[cfg(feature = "extra-children")]
6981 Event::Start(e) => {
6982 let elem = RawXmlElement::from_reader(reader, &e)?;
6983 extra_children
6984 .push(PositionedNode::new(child_idx, RawXmlNode::Element(elem)));
6985 child_idx += 1;
6986 }
6987 #[cfg(not(feature = "extra-children"))]
6988 Event::Start(_) => {
6989 skip_element(reader)?;
6990 }
6991 #[cfg(feature = "extra-children")]
6992 Event::Empty(e) => {
6993 let elem = RawXmlElement::from_empty(&e);
6994 extra_children
6995 .push(PositionedNode::new(child_idx, RawXmlNode::Element(elem)));
6996 child_idx += 1;
6997 }
6998 #[cfg(not(feature = "extra-children"))]
6999 Event::Empty(_) => {}
7000 Event::End(_) => break,
7001 Event::Eof => break,
7002 _ => {}
7003 }
7004 buf.clear();
7005 }
7006 }
7007 Ok(Self {
7008 #[cfg(feature = "extra-children")]
7009 extra_children,
7010 })
7011 }
7012}
7013
7014impl FromXml for CTTagsData {
7015 fn from_xml<R: BufRead>(
7016 reader: &mut Reader<R>,
7017 start_tag: &BytesStart,
7018 is_empty: bool,
7019 ) -> Result<Self, ParseError> {
7020 #[cfg(feature = "extra-children")]
7021 let mut extra_children = Vec::new();
7022 #[cfg(feature = "extra-children")]
7023 let mut child_idx: usize = 0;
7024 if !is_empty {
7025 let mut buf = Vec::new();
7026 loop {
7027 match reader.read_event_into(&mut buf)? {
7028 #[cfg(feature = "extra-children")]
7029 Event::Start(e) => {
7030 let elem = RawXmlElement::from_reader(reader, &e)?;
7031 extra_children
7032 .push(PositionedNode::new(child_idx, RawXmlNode::Element(elem)));
7033 child_idx += 1;
7034 }
7035 #[cfg(not(feature = "extra-children"))]
7036 Event::Start(_) => {
7037 skip_element(reader)?;
7038 }
7039 #[cfg(feature = "extra-children")]
7040 Event::Empty(e) => {
7041 let elem = RawXmlElement::from_empty(&e);
7042 extra_children
7043 .push(PositionedNode::new(child_idx, RawXmlNode::Element(elem)));
7044 child_idx += 1;
7045 }
7046 #[cfg(not(feature = "extra-children"))]
7047 Event::Empty(_) => {}
7048 Event::End(_) => break,
7049 Event::Eof => break,
7050 _ => {}
7051 }
7052 buf.clear();
7053 }
7054 }
7055 Ok(Self {
7056 #[cfg(feature = "extra-children")]
7057 extra_children,
7058 })
7059 }
7060}
7061
7062impl FromXml for CTCustomerDataList {
7063 fn from_xml<R: BufRead>(
7064 reader: &mut Reader<R>,
7065 start_tag: &BytesStart,
7066 is_empty: bool,
7067 ) -> Result<Self, ParseError> {
7068 let mut f_cust_data = Vec::new();
7069 let mut f_tags = None;
7070 #[cfg(feature = "extra-children")]
7071 let mut extra_children = Vec::new();
7072 #[cfg(feature = "extra-children")]
7073 let mut child_idx: usize = 0;
7074
7075 if !is_empty {
7077 let mut buf = Vec::new();
7078 loop {
7079 match reader.read_event_into(&mut buf)? {
7080 Event::Start(e) => {
7081 match e.local_name().as_ref() {
7082 b"custData" => {
7083 f_cust_data.push(CTCustomerData::from_xml(reader, &e, false)?);
7084 #[cfg(feature = "extra-children")]
7085 {
7086 child_idx += 1;
7087 }
7088 }
7089 b"tags" => {
7090 f_tags = Some(Box::new(CTTagsData::from_xml(reader, &e, false)?));
7091 #[cfg(feature = "extra-children")]
7092 {
7093 child_idx += 1;
7094 }
7095 }
7096 #[cfg(feature = "extra-children")]
7097 _ => {
7098 let elem = RawXmlElement::from_reader(reader, &e)?;
7100 extra_children.push(PositionedNode::new(
7101 child_idx,
7102 RawXmlNode::Element(elem),
7103 ));
7104 child_idx += 1;
7105 }
7106 #[cfg(not(feature = "extra-children"))]
7107 _ => {
7108 skip_element(reader)?;
7110 }
7111 }
7112 }
7113 Event::Empty(e) => {
7114 match e.local_name().as_ref() {
7115 b"custData" => {
7116 f_cust_data.push(CTCustomerData::from_xml(reader, &e, true)?);
7117 #[cfg(feature = "extra-children")]
7118 {
7119 child_idx += 1;
7120 }
7121 }
7122 b"tags" => {
7123 f_tags = Some(Box::new(CTTagsData::from_xml(reader, &e, true)?));
7124 #[cfg(feature = "extra-children")]
7125 {
7126 child_idx += 1;
7127 }
7128 }
7129 #[cfg(feature = "extra-children")]
7130 _ => {
7131 let elem = RawXmlElement::from_empty(&e);
7133 extra_children.push(PositionedNode::new(
7134 child_idx,
7135 RawXmlNode::Element(elem),
7136 ));
7137 child_idx += 1;
7138 }
7139 #[cfg(not(feature = "extra-children"))]
7140 _ => {}
7141 }
7142 }
7143 Event::End(_) => break,
7144 Event::Eof => break,
7145 _ => {}
7146 }
7147 buf.clear();
7148 }
7149 }
7150
7151 Ok(Self {
7152 cust_data: f_cust_data,
7153 tags: f_tags,
7154 #[cfg(feature = "extra-children")]
7155 extra_children,
7156 })
7157 }
7158}
7159
7160impl FromXml for CTExtension {
7161 fn from_xml<R: BufRead>(
7162 reader: &mut Reader<R>,
7163 start_tag: &BytesStart,
7164 is_empty: bool,
7165 ) -> Result<Self, ParseError> {
7166 let mut f_uri: Option<String> = None;
7167 #[cfg(feature = "extra-attrs")]
7168 let mut extra_attrs = std::collections::HashMap::new();
7169
7170 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
7172 let val = String::from_utf8_lossy(&attr.value);
7173 match attr.key.local_name().as_ref() {
7174 b"uri" => {
7175 f_uri = Some(val.into_owned());
7176 }
7177 #[cfg(feature = "extra-attrs")]
7178 unknown => {
7179 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
7180 extra_attrs.insert(key, val.into_owned());
7181 }
7182 #[cfg(not(feature = "extra-attrs"))]
7183 _ => {}
7184 }
7185 }
7186
7187 if !is_empty {
7188 let mut buf = Vec::new();
7189 loop {
7190 match reader.read_event_into(&mut buf)? {
7191 Event::End(_) => break,
7192 Event::Eof => break,
7193 _ => {}
7194 }
7195 buf.clear();
7196 }
7197 }
7198
7199 Ok(Self {
7200 uri: f_uri.ok_or_else(|| ParseError::MissingAttribute("uri".to_string()))?,
7201 #[cfg(feature = "extra-attrs")]
7202 extra_attrs,
7203 })
7204 }
7205}
7206
7207impl FromXml for EGExtensionList {
7208 fn from_xml<R: BufRead>(
7209 reader: &mut Reader<R>,
7210 start_tag: &BytesStart,
7211 is_empty: bool,
7212 ) -> Result<Self, ParseError> {
7213 let mut f_ext = Vec::new();
7214 #[cfg(feature = "extra-children")]
7215 let mut extra_children = Vec::new();
7216 #[cfg(feature = "extra-children")]
7217 let mut child_idx: usize = 0;
7218
7219 if !is_empty {
7221 let mut buf = Vec::new();
7222 loop {
7223 match reader.read_event_into(&mut buf)? {
7224 Event::Start(e) => {
7225 match e.local_name().as_ref() {
7226 b"ext" => {
7227 f_ext.push(CTExtension::from_xml(reader, &e, false)?);
7228 #[cfg(feature = "extra-children")]
7229 {
7230 child_idx += 1;
7231 }
7232 }
7233 #[cfg(feature = "extra-children")]
7234 _ => {
7235 let elem = RawXmlElement::from_reader(reader, &e)?;
7237 extra_children.push(PositionedNode::new(
7238 child_idx,
7239 RawXmlNode::Element(elem),
7240 ));
7241 child_idx += 1;
7242 }
7243 #[cfg(not(feature = "extra-children"))]
7244 _ => {
7245 skip_element(reader)?;
7247 }
7248 }
7249 }
7250 Event::Empty(e) => {
7251 match e.local_name().as_ref() {
7252 b"ext" => {
7253 f_ext.push(CTExtension::from_xml(reader, &e, true)?);
7254 #[cfg(feature = "extra-children")]
7255 {
7256 child_idx += 1;
7257 }
7258 }
7259 #[cfg(feature = "extra-children")]
7260 _ => {
7261 let elem = RawXmlElement::from_empty(&e);
7263 extra_children.push(PositionedNode::new(
7264 child_idx,
7265 RawXmlNode::Element(elem),
7266 ));
7267 child_idx += 1;
7268 }
7269 #[cfg(not(feature = "extra-children"))]
7270 _ => {}
7271 }
7272 }
7273 Event::End(_) => break,
7274 Event::Eof => break,
7275 _ => {}
7276 }
7277 buf.clear();
7278 }
7279 }
7280
7281 Ok(Self {
7282 ext: f_ext,
7283 #[cfg(feature = "extra-children")]
7284 extra_children,
7285 })
7286 }
7287}
7288
7289impl FromXml for CTExtensionList {
7290 fn from_xml<R: BufRead>(
7291 reader: &mut Reader<R>,
7292 start_tag: &BytesStart,
7293 is_empty: bool,
7294 ) -> Result<Self, ParseError> {
7295 let mut f_ext = Vec::new();
7296 #[cfg(feature = "extra-children")]
7297 let mut extra_children = Vec::new();
7298 #[cfg(feature = "extra-children")]
7299 let mut child_idx: usize = 0;
7300
7301 if !is_empty {
7303 let mut buf = Vec::new();
7304 loop {
7305 match reader.read_event_into(&mut buf)? {
7306 Event::Start(e) => {
7307 match e.local_name().as_ref() {
7308 b"ext" => {
7309 f_ext.push(CTExtension::from_xml(reader, &e, false)?);
7310 #[cfg(feature = "extra-children")]
7311 {
7312 child_idx += 1;
7313 }
7314 }
7315 #[cfg(feature = "extra-children")]
7316 _ => {
7317 let elem = RawXmlElement::from_reader(reader, &e)?;
7319 extra_children.push(PositionedNode::new(
7320 child_idx,
7321 RawXmlNode::Element(elem),
7322 ));
7323 child_idx += 1;
7324 }
7325 #[cfg(not(feature = "extra-children"))]
7326 _ => {
7327 skip_element(reader)?;
7329 }
7330 }
7331 }
7332 Event::Empty(e) => {
7333 match e.local_name().as_ref() {
7334 b"ext" => {
7335 f_ext.push(CTExtension::from_xml(reader, &e, true)?);
7336 #[cfg(feature = "extra-children")]
7337 {
7338 child_idx += 1;
7339 }
7340 }
7341 #[cfg(feature = "extra-children")]
7342 _ => {
7343 let elem = RawXmlElement::from_empty(&e);
7345 extra_children.push(PositionedNode::new(
7346 child_idx,
7347 RawXmlNode::Element(elem),
7348 ));
7349 child_idx += 1;
7350 }
7351 #[cfg(not(feature = "extra-children"))]
7352 _ => {}
7353 }
7354 }
7355 Event::End(_) => break,
7356 Event::Eof => break,
7357 _ => {}
7358 }
7359 buf.clear();
7360 }
7361 }
7362
7363 Ok(Self {
7364 ext: f_ext,
7365 #[cfg(feature = "extra-children")]
7366 extra_children,
7367 })
7368 }
7369}
7370
7371impl FromXml for CTExtensionListModify {
7372 fn from_xml<R: BufRead>(
7373 reader: &mut Reader<R>,
7374 start_tag: &BytesStart,
7375 is_empty: bool,
7376 ) -> Result<Self, ParseError> {
7377 let mut f_mod = None;
7378 let mut f_ext = Vec::new();
7379 #[cfg(feature = "extra-attrs")]
7380 let mut extra_attrs = std::collections::HashMap::new();
7381 #[cfg(feature = "extra-children")]
7382 let mut extra_children = Vec::new();
7383 #[cfg(feature = "extra-children")]
7384 let mut child_idx: usize = 0;
7385
7386 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
7388 let val = String::from_utf8_lossy(&attr.value);
7389 match attr.key.local_name().as_ref() {
7390 b"mod" => {
7391 f_mod = Some(val == "true" || val == "1");
7392 }
7393 #[cfg(feature = "extra-attrs")]
7394 unknown => {
7395 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
7396 extra_attrs.insert(key, val.into_owned());
7397 }
7398 #[cfg(not(feature = "extra-attrs"))]
7399 _ => {}
7400 }
7401 }
7402
7403 if !is_empty {
7405 let mut buf = Vec::new();
7406 loop {
7407 match reader.read_event_into(&mut buf)? {
7408 Event::Start(e) => {
7409 match e.local_name().as_ref() {
7410 b"ext" => {
7411 f_ext.push(CTExtension::from_xml(reader, &e, false)?);
7412 #[cfg(feature = "extra-children")]
7413 {
7414 child_idx += 1;
7415 }
7416 }
7417 #[cfg(feature = "extra-children")]
7418 _ => {
7419 let elem = RawXmlElement::from_reader(reader, &e)?;
7421 extra_children.push(PositionedNode::new(
7422 child_idx,
7423 RawXmlNode::Element(elem),
7424 ));
7425 child_idx += 1;
7426 }
7427 #[cfg(not(feature = "extra-children"))]
7428 _ => {
7429 skip_element(reader)?;
7431 }
7432 }
7433 }
7434 Event::Empty(e) => {
7435 match e.local_name().as_ref() {
7436 b"ext" => {
7437 f_ext.push(CTExtension::from_xml(reader, &e, true)?);
7438 #[cfg(feature = "extra-children")]
7439 {
7440 child_idx += 1;
7441 }
7442 }
7443 #[cfg(feature = "extra-children")]
7444 _ => {
7445 let elem = RawXmlElement::from_empty(&e);
7447 extra_children.push(PositionedNode::new(
7448 child_idx,
7449 RawXmlNode::Element(elem),
7450 ));
7451 child_idx += 1;
7452 }
7453 #[cfg(not(feature = "extra-children"))]
7454 _ => {}
7455 }
7456 }
7457 Event::End(_) => break,
7458 Event::Eof => break,
7459 _ => {}
7460 }
7461 buf.clear();
7462 }
7463 }
7464
7465 Ok(Self {
7466 r#mod: f_mod,
7467 ext: f_ext,
7468 #[cfg(feature = "extra-attrs")]
7469 extra_attrs,
7470 #[cfg(feature = "extra-children")]
7471 extra_children,
7472 })
7473 }
7474}
7475
7476impl FromXml for CTCommentAuthor {
7477 fn from_xml<R: BufRead>(
7478 reader: &mut Reader<R>,
7479 start_tag: &BytesStart,
7480 is_empty: bool,
7481 ) -> Result<Self, ParseError> {
7482 #[cfg(feature = "pml-comments")]
7483 let mut f_id: Option<u32> = None;
7484 #[cfg(feature = "pml-comments")]
7485 let mut f_name: Option<STName> = None;
7486 #[cfg(feature = "pml-comments")]
7487 let mut f_initials: Option<STName> = None;
7488 #[cfg(feature = "pml-comments")]
7489 let mut f_last_idx: Option<u32> = None;
7490 #[cfg(feature = "pml-comments")]
7491 let mut f_clr_idx: Option<u32> = None;
7492 #[cfg(feature = "pml-extensions")]
7493 let mut f_ext_lst = None;
7494 #[cfg(feature = "extra-attrs")]
7495 let mut extra_attrs = std::collections::HashMap::new();
7496 #[cfg(feature = "extra-children")]
7497 let mut extra_children = Vec::new();
7498 #[cfg(feature = "extra-children")]
7499 let mut child_idx: usize = 0;
7500
7501 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
7503 let val = String::from_utf8_lossy(&attr.value);
7504 match attr.key.local_name().as_ref() {
7505 #[cfg(feature = "pml-comments")]
7506 b"id" => {
7507 f_id = val.parse().ok();
7508 }
7509 #[cfg(feature = "pml-comments")]
7510 b"name" => {
7511 f_name = Some(val.into_owned());
7512 }
7513 #[cfg(feature = "pml-comments")]
7514 b"initials" => {
7515 f_initials = Some(val.into_owned());
7516 }
7517 #[cfg(feature = "pml-comments")]
7518 b"lastIdx" => {
7519 f_last_idx = val.parse().ok();
7520 }
7521 #[cfg(feature = "pml-comments")]
7522 b"clrIdx" => {
7523 f_clr_idx = val.parse().ok();
7524 }
7525 #[cfg(feature = "extra-attrs")]
7526 unknown => {
7527 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
7528 extra_attrs.insert(key, val.into_owned());
7529 }
7530 #[cfg(not(feature = "extra-attrs"))]
7531 _ => {}
7532 }
7533 }
7534
7535 if !is_empty {
7537 let mut buf = Vec::new();
7538 loop {
7539 match reader.read_event_into(&mut buf)? {
7540 Event::Start(e) => {
7541 match e.local_name().as_ref() {
7542 #[cfg(feature = "pml-extensions")]
7543 b"extLst" => {
7544 f_ext_lst =
7545 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
7546 #[cfg(feature = "extra-children")]
7547 {
7548 child_idx += 1;
7549 }
7550 }
7551 #[cfg(feature = "extra-children")]
7552 _ => {
7553 let elem = RawXmlElement::from_reader(reader, &e)?;
7555 extra_children.push(PositionedNode::new(
7556 child_idx,
7557 RawXmlNode::Element(elem),
7558 ));
7559 child_idx += 1;
7560 }
7561 #[cfg(not(feature = "extra-children"))]
7562 _ => {
7563 skip_element(reader)?;
7565 }
7566 }
7567 }
7568 Event::Empty(e) => {
7569 match e.local_name().as_ref() {
7570 #[cfg(feature = "pml-extensions")]
7571 b"extLst" => {
7572 f_ext_lst =
7573 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
7574 #[cfg(feature = "extra-children")]
7575 {
7576 child_idx += 1;
7577 }
7578 }
7579 #[cfg(feature = "extra-children")]
7580 _ => {
7581 let elem = RawXmlElement::from_empty(&e);
7583 extra_children.push(PositionedNode::new(
7584 child_idx,
7585 RawXmlNode::Element(elem),
7586 ));
7587 child_idx += 1;
7588 }
7589 #[cfg(not(feature = "extra-children"))]
7590 _ => {}
7591 }
7592 }
7593 Event::End(_) => break,
7594 Event::Eof => break,
7595 _ => {}
7596 }
7597 buf.clear();
7598 }
7599 }
7600
7601 Ok(Self {
7602 #[cfg(feature = "pml-comments")]
7603 id: f_id.ok_or_else(|| ParseError::MissingAttribute("id".to_string()))?,
7604 #[cfg(feature = "pml-comments")]
7605 name: f_name.ok_or_else(|| ParseError::MissingAttribute("name".to_string()))?,
7606 #[cfg(feature = "pml-comments")]
7607 initials: f_initials
7608 .ok_or_else(|| ParseError::MissingAttribute("initials".to_string()))?,
7609 #[cfg(feature = "pml-comments")]
7610 last_idx: f_last_idx
7611 .ok_or_else(|| ParseError::MissingAttribute("lastIdx".to_string()))?,
7612 #[cfg(feature = "pml-comments")]
7613 clr_idx: f_clr_idx.ok_or_else(|| ParseError::MissingAttribute("clrIdx".to_string()))?,
7614 #[cfg(feature = "pml-extensions")]
7615 ext_lst: f_ext_lst,
7616 #[cfg(feature = "extra-attrs")]
7617 extra_attrs,
7618 #[cfg(feature = "extra-children")]
7619 extra_children,
7620 })
7621 }
7622}
7623
7624impl FromXml for CTCommentAuthorList {
7625 fn from_xml<R: BufRead>(
7626 reader: &mut Reader<R>,
7627 start_tag: &BytesStart,
7628 is_empty: bool,
7629 ) -> Result<Self, ParseError> {
7630 let mut f_cm_author = Vec::new();
7631 #[cfg(feature = "extra-children")]
7632 let mut extra_children = Vec::new();
7633 #[cfg(feature = "extra-children")]
7634 let mut child_idx: usize = 0;
7635
7636 if !is_empty {
7638 let mut buf = Vec::new();
7639 loop {
7640 match reader.read_event_into(&mut buf)? {
7641 Event::Start(e) => {
7642 match e.local_name().as_ref() {
7643 b"cmAuthor" => {
7644 f_cm_author.push(CTCommentAuthor::from_xml(reader, &e, false)?);
7645 #[cfg(feature = "extra-children")]
7646 {
7647 child_idx += 1;
7648 }
7649 }
7650 #[cfg(feature = "extra-children")]
7651 _ => {
7652 let elem = RawXmlElement::from_reader(reader, &e)?;
7654 extra_children.push(PositionedNode::new(
7655 child_idx,
7656 RawXmlNode::Element(elem),
7657 ));
7658 child_idx += 1;
7659 }
7660 #[cfg(not(feature = "extra-children"))]
7661 _ => {
7662 skip_element(reader)?;
7664 }
7665 }
7666 }
7667 Event::Empty(e) => {
7668 match e.local_name().as_ref() {
7669 b"cmAuthor" => {
7670 f_cm_author.push(CTCommentAuthor::from_xml(reader, &e, true)?);
7671 #[cfg(feature = "extra-children")]
7672 {
7673 child_idx += 1;
7674 }
7675 }
7676 #[cfg(feature = "extra-children")]
7677 _ => {
7678 let elem = RawXmlElement::from_empty(&e);
7680 extra_children.push(PositionedNode::new(
7681 child_idx,
7682 RawXmlNode::Element(elem),
7683 ));
7684 child_idx += 1;
7685 }
7686 #[cfg(not(feature = "extra-children"))]
7687 _ => {}
7688 }
7689 }
7690 Event::End(_) => break,
7691 Event::Eof => break,
7692 _ => {}
7693 }
7694 buf.clear();
7695 }
7696 }
7697
7698 Ok(Self {
7699 cm_author: f_cm_author,
7700 #[cfg(feature = "extra-children")]
7701 extra_children,
7702 })
7703 }
7704}
7705
7706impl FromXml for CTComment {
7707 fn from_xml<R: BufRead>(
7708 reader: &mut Reader<R>,
7709 start_tag: &BytesStart,
7710 is_empty: bool,
7711 ) -> Result<Self, ParseError> {
7712 #[cfg(feature = "pml-comments")]
7713 let mut f_author_id: Option<u32> = None;
7714 #[cfg(feature = "pml-comments")]
7715 let mut f_dt = None;
7716 #[cfg(feature = "pml-comments")]
7717 let mut f_idx: Option<STIndex> = None;
7718 #[cfg(feature = "pml-comments")]
7719 let mut f_pos: Option<Box<ooxml_dml::types::Point2D>> = None;
7720 #[cfg(feature = "pml-comments")]
7721 let mut f_text: Option<String> = None;
7722 #[cfg(feature = "pml-extensions")]
7723 let mut f_ext_lst = None;
7724 #[cfg(feature = "extra-attrs")]
7725 let mut extra_attrs = std::collections::HashMap::new();
7726 #[cfg(feature = "extra-children")]
7727 let mut extra_children = Vec::new();
7728 #[cfg(feature = "extra-children")]
7729 let mut child_idx: usize = 0;
7730
7731 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
7733 let val = String::from_utf8_lossy(&attr.value);
7734 match attr.key.local_name().as_ref() {
7735 #[cfg(feature = "pml-comments")]
7736 b"authorId" => {
7737 f_author_id = val.parse().ok();
7738 }
7739 #[cfg(feature = "pml-comments")]
7740 b"dt" => {
7741 f_dt = Some(val.into_owned());
7742 }
7743 #[cfg(feature = "pml-comments")]
7744 b"idx" => {
7745 f_idx = val.parse().ok();
7746 }
7747 #[cfg(feature = "extra-attrs")]
7748 unknown => {
7749 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
7750 extra_attrs.insert(key, val.into_owned());
7751 }
7752 #[cfg(not(feature = "extra-attrs"))]
7753 _ => {}
7754 }
7755 }
7756
7757 if !is_empty {
7759 let mut buf = Vec::new();
7760 loop {
7761 match reader.read_event_into(&mut buf)? {
7762 Event::Start(e) => {
7763 match e.local_name().as_ref() {
7764 #[cfg(feature = "pml-comments")]
7765 b"pos" => {
7766 f_pos = Some(Box::new(ooxml_dml::types::Point2D::from_xml(
7767 reader, &e, false,
7768 )?));
7769 #[cfg(feature = "extra-children")]
7770 {
7771 child_idx += 1;
7772 }
7773 }
7774 #[cfg(feature = "pml-comments")]
7775 b"text" => {
7776 f_text = Some(read_text_content(reader)?);
7777 #[cfg(feature = "extra-children")]
7778 {
7779 child_idx += 1;
7780 }
7781 }
7782 #[cfg(feature = "pml-extensions")]
7783 b"extLst" => {
7784 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
7785 reader, &e, false,
7786 )?));
7787 #[cfg(feature = "extra-children")]
7788 {
7789 child_idx += 1;
7790 }
7791 }
7792 #[cfg(feature = "extra-children")]
7793 _ => {
7794 let elem = RawXmlElement::from_reader(reader, &e)?;
7796 extra_children.push(PositionedNode::new(
7797 child_idx,
7798 RawXmlNode::Element(elem),
7799 ));
7800 child_idx += 1;
7801 }
7802 #[cfg(not(feature = "extra-children"))]
7803 _ => {
7804 skip_element(reader)?;
7806 }
7807 }
7808 }
7809 Event::Empty(e) => {
7810 match e.local_name().as_ref() {
7811 #[cfg(feature = "pml-comments")]
7812 b"pos" => {
7813 f_pos = Some(Box::new(ooxml_dml::types::Point2D::from_xml(
7814 reader, &e, true,
7815 )?));
7816 #[cfg(feature = "extra-children")]
7817 {
7818 child_idx += 1;
7819 }
7820 }
7821 #[cfg(feature = "pml-comments")]
7822 b"text" => {
7823 f_text = Some(String::new());
7824 #[cfg(feature = "extra-children")]
7825 {
7826 child_idx += 1;
7827 }
7828 }
7829 #[cfg(feature = "pml-extensions")]
7830 b"extLst" => {
7831 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
7832 reader, &e, true,
7833 )?));
7834 #[cfg(feature = "extra-children")]
7835 {
7836 child_idx += 1;
7837 }
7838 }
7839 #[cfg(feature = "extra-children")]
7840 _ => {
7841 let elem = RawXmlElement::from_empty(&e);
7843 extra_children.push(PositionedNode::new(
7844 child_idx,
7845 RawXmlNode::Element(elem),
7846 ));
7847 child_idx += 1;
7848 }
7849 #[cfg(not(feature = "extra-children"))]
7850 _ => {}
7851 }
7852 }
7853 Event::End(_) => break,
7854 Event::Eof => break,
7855 _ => {}
7856 }
7857 buf.clear();
7858 }
7859 }
7860
7861 Ok(Self {
7862 #[cfg(feature = "pml-comments")]
7863 author_id: f_author_id
7864 .ok_or_else(|| ParseError::MissingAttribute("authorId".to_string()))?,
7865 #[cfg(feature = "pml-comments")]
7866 dt: f_dt,
7867 #[cfg(feature = "pml-comments")]
7868 idx: f_idx.ok_or_else(|| ParseError::MissingAttribute("idx".to_string()))?,
7869 #[cfg(feature = "pml-comments")]
7870 pos: f_pos.ok_or_else(|| ParseError::MissingAttribute("pos".to_string()))?,
7871 #[cfg(feature = "pml-comments")]
7872 text: f_text.ok_or_else(|| ParseError::MissingAttribute("text".to_string()))?,
7873 #[cfg(feature = "pml-extensions")]
7874 ext_lst: f_ext_lst,
7875 #[cfg(feature = "extra-attrs")]
7876 extra_attrs,
7877 #[cfg(feature = "extra-children")]
7878 extra_children,
7879 })
7880 }
7881}
7882
7883impl FromXml for CTCommentList {
7884 fn from_xml<R: BufRead>(
7885 reader: &mut Reader<R>,
7886 start_tag: &BytesStart,
7887 is_empty: bool,
7888 ) -> Result<Self, ParseError> {
7889 let mut f_cm = Vec::new();
7890 #[cfg(feature = "extra-children")]
7891 let mut extra_children = Vec::new();
7892 #[cfg(feature = "extra-children")]
7893 let mut child_idx: usize = 0;
7894
7895 if !is_empty {
7897 let mut buf = Vec::new();
7898 loop {
7899 match reader.read_event_into(&mut buf)? {
7900 Event::Start(e) => {
7901 match e.local_name().as_ref() {
7902 b"cm" => {
7903 f_cm.push(CTComment::from_xml(reader, &e, false)?);
7904 #[cfg(feature = "extra-children")]
7905 {
7906 child_idx += 1;
7907 }
7908 }
7909 #[cfg(feature = "extra-children")]
7910 _ => {
7911 let elem = RawXmlElement::from_reader(reader, &e)?;
7913 extra_children.push(PositionedNode::new(
7914 child_idx,
7915 RawXmlNode::Element(elem),
7916 ));
7917 child_idx += 1;
7918 }
7919 #[cfg(not(feature = "extra-children"))]
7920 _ => {
7921 skip_element(reader)?;
7923 }
7924 }
7925 }
7926 Event::Empty(e) => {
7927 match e.local_name().as_ref() {
7928 b"cm" => {
7929 f_cm.push(CTComment::from_xml(reader, &e, true)?);
7930 #[cfg(feature = "extra-children")]
7931 {
7932 child_idx += 1;
7933 }
7934 }
7935 #[cfg(feature = "extra-children")]
7936 _ => {
7937 let elem = RawXmlElement::from_empty(&e);
7939 extra_children.push(PositionedNode::new(
7940 child_idx,
7941 RawXmlNode::Element(elem),
7942 ));
7943 child_idx += 1;
7944 }
7945 #[cfg(not(feature = "extra-children"))]
7946 _ => {}
7947 }
7948 }
7949 Event::End(_) => break,
7950 Event::Eof => break,
7951 _ => {}
7952 }
7953 buf.clear();
7954 }
7955 }
7956
7957 Ok(Self {
7958 cm: f_cm,
7959 #[cfg(feature = "extra-children")]
7960 extra_children,
7961 })
7962 }
7963}
7964
7965impl FromXml for PAGOle {
7966 fn from_xml<R: BufRead>(
7967 reader: &mut Reader<R>,
7968 start_tag: &BytesStart,
7969 is_empty: bool,
7970 ) -> Result<Self, ParseError> {
7971 let mut f_name = None;
7972 let mut f_show_as_icon = None;
7973 let mut f_img_w = None;
7974 let mut f_img_h = None;
7975 #[cfg(feature = "extra-attrs")]
7976 let mut extra_attrs = std::collections::HashMap::new();
7977
7978 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
7980 let val = String::from_utf8_lossy(&attr.value);
7981 match attr.key.local_name().as_ref() {
7982 b"name" => {
7983 f_name = Some(val.into_owned());
7984 }
7985 b"showAsIcon" => {
7986 f_show_as_icon = Some(val == "true" || val == "1");
7987 }
7988 b"imgW" => {
7989 f_img_w = val.parse().ok();
7990 }
7991 b"imgH" => {
7992 f_img_h = val.parse().ok();
7993 }
7994 #[cfg(feature = "extra-attrs")]
7995 unknown => {
7996 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
7997 extra_attrs.insert(key, val.into_owned());
7998 }
7999 #[cfg(not(feature = "extra-attrs"))]
8000 _ => {}
8001 }
8002 }
8003
8004 if !is_empty {
8005 let mut buf = Vec::new();
8006 loop {
8007 match reader.read_event_into(&mut buf)? {
8008 Event::End(_) => break,
8009 Event::Eof => break,
8010 _ => {}
8011 }
8012 buf.clear();
8013 }
8014 }
8015
8016 Ok(Self {
8017 name: f_name,
8018 show_as_icon: f_show_as_icon,
8019 img_w: f_img_w,
8020 img_h: f_img_h,
8021 #[cfg(feature = "extra-attrs")]
8022 extra_attrs,
8023 })
8024 }
8025}
8026
8027impl FromXml for CTOleObjectEmbed {
8028 fn from_xml<R: BufRead>(
8029 reader: &mut Reader<R>,
8030 start_tag: &BytesStart,
8031 is_empty: bool,
8032 ) -> Result<Self, ParseError> {
8033 let mut f_follow_color_scheme = None;
8034 let mut f_ext_lst = None;
8035 #[cfg(feature = "extra-attrs")]
8036 let mut extra_attrs = std::collections::HashMap::new();
8037 #[cfg(feature = "extra-children")]
8038 let mut extra_children = Vec::new();
8039 #[cfg(feature = "extra-children")]
8040 let mut child_idx: usize = 0;
8041
8042 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
8044 let val = String::from_utf8_lossy(&attr.value);
8045 match attr.key.local_name().as_ref() {
8046 b"followColorScheme" => {
8047 f_follow_color_scheme = val.parse().ok();
8048 }
8049 #[cfg(feature = "extra-attrs")]
8050 unknown => {
8051 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
8052 extra_attrs.insert(key, val.into_owned());
8053 }
8054 #[cfg(not(feature = "extra-attrs"))]
8055 _ => {}
8056 }
8057 }
8058
8059 if !is_empty {
8061 let mut buf = Vec::new();
8062 loop {
8063 match reader.read_event_into(&mut buf)? {
8064 Event::Start(e) => {
8065 match e.local_name().as_ref() {
8066 b"extLst" => {
8067 f_ext_lst =
8068 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
8069 #[cfg(feature = "extra-children")]
8070 {
8071 child_idx += 1;
8072 }
8073 }
8074 #[cfg(feature = "extra-children")]
8075 _ => {
8076 let elem = RawXmlElement::from_reader(reader, &e)?;
8078 extra_children.push(PositionedNode::new(
8079 child_idx,
8080 RawXmlNode::Element(elem),
8081 ));
8082 child_idx += 1;
8083 }
8084 #[cfg(not(feature = "extra-children"))]
8085 _ => {
8086 skip_element(reader)?;
8088 }
8089 }
8090 }
8091 Event::Empty(e) => {
8092 match e.local_name().as_ref() {
8093 b"extLst" => {
8094 f_ext_lst =
8095 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
8096 #[cfg(feature = "extra-children")]
8097 {
8098 child_idx += 1;
8099 }
8100 }
8101 #[cfg(feature = "extra-children")]
8102 _ => {
8103 let elem = RawXmlElement::from_empty(&e);
8105 extra_children.push(PositionedNode::new(
8106 child_idx,
8107 RawXmlNode::Element(elem),
8108 ));
8109 child_idx += 1;
8110 }
8111 #[cfg(not(feature = "extra-children"))]
8112 _ => {}
8113 }
8114 }
8115 Event::End(_) => break,
8116 Event::Eof => break,
8117 _ => {}
8118 }
8119 buf.clear();
8120 }
8121 }
8122
8123 Ok(Self {
8124 follow_color_scheme: f_follow_color_scheme,
8125 ext_lst: f_ext_lst,
8126 #[cfg(feature = "extra-attrs")]
8127 extra_attrs,
8128 #[cfg(feature = "extra-children")]
8129 extra_children,
8130 })
8131 }
8132}
8133
8134impl FromXml for CTOleObjectLink {
8135 fn from_xml<R: BufRead>(
8136 reader: &mut Reader<R>,
8137 start_tag: &BytesStart,
8138 is_empty: bool,
8139 ) -> Result<Self, ParseError> {
8140 let mut f_update_automatic = None;
8141 let mut f_ext_lst = None;
8142 #[cfg(feature = "extra-attrs")]
8143 let mut extra_attrs = std::collections::HashMap::new();
8144 #[cfg(feature = "extra-children")]
8145 let mut extra_children = Vec::new();
8146 #[cfg(feature = "extra-children")]
8147 let mut child_idx: usize = 0;
8148
8149 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
8151 let val = String::from_utf8_lossy(&attr.value);
8152 match attr.key.local_name().as_ref() {
8153 b"updateAutomatic" => {
8154 f_update_automatic = Some(val == "true" || val == "1");
8155 }
8156 #[cfg(feature = "extra-attrs")]
8157 unknown => {
8158 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
8159 extra_attrs.insert(key, val.into_owned());
8160 }
8161 #[cfg(not(feature = "extra-attrs"))]
8162 _ => {}
8163 }
8164 }
8165
8166 if !is_empty {
8168 let mut buf = Vec::new();
8169 loop {
8170 match reader.read_event_into(&mut buf)? {
8171 Event::Start(e) => {
8172 match e.local_name().as_ref() {
8173 b"extLst" => {
8174 f_ext_lst =
8175 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
8176 #[cfg(feature = "extra-children")]
8177 {
8178 child_idx += 1;
8179 }
8180 }
8181 #[cfg(feature = "extra-children")]
8182 _ => {
8183 let elem = RawXmlElement::from_reader(reader, &e)?;
8185 extra_children.push(PositionedNode::new(
8186 child_idx,
8187 RawXmlNode::Element(elem),
8188 ));
8189 child_idx += 1;
8190 }
8191 #[cfg(not(feature = "extra-children"))]
8192 _ => {
8193 skip_element(reader)?;
8195 }
8196 }
8197 }
8198 Event::Empty(e) => {
8199 match e.local_name().as_ref() {
8200 b"extLst" => {
8201 f_ext_lst =
8202 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
8203 #[cfg(feature = "extra-children")]
8204 {
8205 child_idx += 1;
8206 }
8207 }
8208 #[cfg(feature = "extra-children")]
8209 _ => {
8210 let elem = RawXmlElement::from_empty(&e);
8212 extra_children.push(PositionedNode::new(
8213 child_idx,
8214 RawXmlNode::Element(elem),
8215 ));
8216 child_idx += 1;
8217 }
8218 #[cfg(not(feature = "extra-children"))]
8219 _ => {}
8220 }
8221 }
8222 Event::End(_) => break,
8223 Event::Eof => break,
8224 _ => {}
8225 }
8226 buf.clear();
8227 }
8228 }
8229
8230 Ok(Self {
8231 update_automatic: f_update_automatic,
8232 ext_lst: f_ext_lst,
8233 #[cfg(feature = "extra-attrs")]
8234 extra_attrs,
8235 #[cfg(feature = "extra-children")]
8236 extra_children,
8237 })
8238 }
8239}
8240
8241impl FromXml for CTOleObject {
8242 fn from_xml<R: BufRead>(
8243 reader: &mut Reader<R>,
8244 start_tag: &BytesStart,
8245 is_empty: bool,
8246 ) -> Result<Self, ParseError> {
8247 let mut f_name = None;
8248 let mut f_show_as_icon = None;
8249 let mut f_img_w = None;
8250 let mut f_img_h = None;
8251 let mut f_prog_id = None;
8252 let mut f_embed = None;
8253 let mut f_link = None;
8254 let mut f_spid = None;
8255 let mut f_picture = None;
8256 #[cfg(feature = "extra-attrs")]
8257 let mut extra_attrs = std::collections::HashMap::new();
8258 #[cfg(feature = "extra-children")]
8259 let mut extra_children = Vec::new();
8260 #[cfg(feature = "extra-children")]
8261 let mut child_idx: usize = 0;
8262
8263 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
8265 let val = String::from_utf8_lossy(&attr.value);
8266 match attr.key.local_name().as_ref() {
8267 b"name" => {
8268 f_name = Some(val.into_owned());
8269 }
8270 b"showAsIcon" => {
8271 f_show_as_icon = Some(val == "true" || val == "1");
8272 }
8273 b"imgW" => {
8274 f_img_w = val.parse().ok();
8275 }
8276 b"imgH" => {
8277 f_img_h = val.parse().ok();
8278 }
8279 b"progId" => {
8280 f_prog_id = Some(val.into_owned());
8281 }
8282 b"spid" => {
8283 f_spid = val.parse().ok();
8284 }
8285 #[cfg(feature = "extra-attrs")]
8286 unknown => {
8287 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
8288 extra_attrs.insert(key, val.into_owned());
8289 }
8290 #[cfg(not(feature = "extra-attrs"))]
8291 _ => {}
8292 }
8293 }
8294
8295 if !is_empty {
8297 let mut buf = Vec::new();
8298 loop {
8299 match reader.read_event_into(&mut buf)? {
8300 Event::Start(e) => {
8301 match e.local_name().as_ref() {
8302 b"embed" => {
8303 f_embed =
8304 Some(Box::new(CTOleObjectEmbed::from_xml(reader, &e, false)?));
8305 #[cfg(feature = "extra-children")]
8306 {
8307 child_idx += 1;
8308 }
8309 }
8310 b"link" => {
8311 f_link =
8312 Some(Box::new(CTOleObjectLink::from_xml(reader, &e, false)?));
8313 #[cfg(feature = "extra-children")]
8314 {
8315 child_idx += 1;
8316 }
8317 }
8318 b"pic" => {
8319 f_picture = Some(Box::new(Picture::from_xml(reader, &e, false)?));
8320 #[cfg(feature = "extra-children")]
8321 {
8322 child_idx += 1;
8323 }
8324 }
8325 #[cfg(feature = "extra-children")]
8326 _ => {
8327 let elem = RawXmlElement::from_reader(reader, &e)?;
8329 extra_children.push(PositionedNode::new(
8330 child_idx,
8331 RawXmlNode::Element(elem),
8332 ));
8333 child_idx += 1;
8334 }
8335 #[cfg(not(feature = "extra-children"))]
8336 _ => {
8337 skip_element(reader)?;
8339 }
8340 }
8341 }
8342 Event::Empty(e) => {
8343 match e.local_name().as_ref() {
8344 b"embed" => {
8345 f_embed =
8346 Some(Box::new(CTOleObjectEmbed::from_xml(reader, &e, true)?));
8347 #[cfg(feature = "extra-children")]
8348 {
8349 child_idx += 1;
8350 }
8351 }
8352 b"link" => {
8353 f_link =
8354 Some(Box::new(CTOleObjectLink::from_xml(reader, &e, true)?));
8355 #[cfg(feature = "extra-children")]
8356 {
8357 child_idx += 1;
8358 }
8359 }
8360 b"pic" => {
8361 f_picture = Some(Box::new(Picture::from_xml(reader, &e, true)?));
8362 #[cfg(feature = "extra-children")]
8363 {
8364 child_idx += 1;
8365 }
8366 }
8367 #[cfg(feature = "extra-children")]
8368 _ => {
8369 let elem = RawXmlElement::from_empty(&e);
8371 extra_children.push(PositionedNode::new(
8372 child_idx,
8373 RawXmlNode::Element(elem),
8374 ));
8375 child_idx += 1;
8376 }
8377 #[cfg(not(feature = "extra-children"))]
8378 _ => {}
8379 }
8380 }
8381 Event::End(_) => break,
8382 Event::Eof => break,
8383 _ => {}
8384 }
8385 buf.clear();
8386 }
8387 }
8388
8389 Ok(Self {
8390 name: f_name,
8391 show_as_icon: f_show_as_icon,
8392 img_w: f_img_w,
8393 img_h: f_img_h,
8394 prog_id: f_prog_id,
8395 embed: f_embed,
8396 link: f_link,
8397 spid: f_spid,
8398 picture: f_picture,
8399 #[cfg(feature = "extra-attrs")]
8400 extra_attrs,
8401 #[cfg(feature = "extra-children")]
8402 extra_children,
8403 })
8404 }
8405}
8406
8407impl FromXml for CTControl {
8408 fn from_xml<R: BufRead>(
8409 reader: &mut Reader<R>,
8410 start_tag: &BytesStart,
8411 is_empty: bool,
8412 ) -> Result<Self, ParseError> {
8413 let mut f_name = None;
8414 let mut f_show_as_icon = None;
8415 let mut f_img_w = None;
8416 let mut f_img_h = None;
8417 let mut f_ext_lst = None;
8418 let mut f_spid = None;
8419 let mut f_picture = None;
8420 #[cfg(feature = "extra-attrs")]
8421 let mut extra_attrs = std::collections::HashMap::new();
8422 #[cfg(feature = "extra-children")]
8423 let mut extra_children = Vec::new();
8424 #[cfg(feature = "extra-children")]
8425 let mut child_idx: usize = 0;
8426
8427 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
8429 let val = String::from_utf8_lossy(&attr.value);
8430 match attr.key.local_name().as_ref() {
8431 b"name" => {
8432 f_name = Some(val.into_owned());
8433 }
8434 b"showAsIcon" => {
8435 f_show_as_icon = Some(val == "true" || val == "1");
8436 }
8437 b"imgW" => {
8438 f_img_w = val.parse().ok();
8439 }
8440 b"imgH" => {
8441 f_img_h = val.parse().ok();
8442 }
8443 b"spid" => {
8444 f_spid = val.parse().ok();
8445 }
8446 #[cfg(feature = "extra-attrs")]
8447 unknown => {
8448 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
8449 extra_attrs.insert(key, val.into_owned());
8450 }
8451 #[cfg(not(feature = "extra-attrs"))]
8452 _ => {}
8453 }
8454 }
8455
8456 if !is_empty {
8458 let mut buf = Vec::new();
8459 loop {
8460 match reader.read_event_into(&mut buf)? {
8461 Event::Start(e) => {
8462 match e.local_name().as_ref() {
8463 b"extLst" => {
8464 f_ext_lst =
8465 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
8466 #[cfg(feature = "extra-children")]
8467 {
8468 child_idx += 1;
8469 }
8470 }
8471 b"pic" => {
8472 f_picture = Some(Box::new(Picture::from_xml(reader, &e, false)?));
8473 #[cfg(feature = "extra-children")]
8474 {
8475 child_idx += 1;
8476 }
8477 }
8478 #[cfg(feature = "extra-children")]
8479 _ => {
8480 let elem = RawXmlElement::from_reader(reader, &e)?;
8482 extra_children.push(PositionedNode::new(
8483 child_idx,
8484 RawXmlNode::Element(elem),
8485 ));
8486 child_idx += 1;
8487 }
8488 #[cfg(not(feature = "extra-children"))]
8489 _ => {
8490 skip_element(reader)?;
8492 }
8493 }
8494 }
8495 Event::Empty(e) => {
8496 match e.local_name().as_ref() {
8497 b"extLst" => {
8498 f_ext_lst =
8499 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
8500 #[cfg(feature = "extra-children")]
8501 {
8502 child_idx += 1;
8503 }
8504 }
8505 b"pic" => {
8506 f_picture = Some(Box::new(Picture::from_xml(reader, &e, true)?));
8507 #[cfg(feature = "extra-children")]
8508 {
8509 child_idx += 1;
8510 }
8511 }
8512 #[cfg(feature = "extra-children")]
8513 _ => {
8514 let elem = RawXmlElement::from_empty(&e);
8516 extra_children.push(PositionedNode::new(
8517 child_idx,
8518 RawXmlNode::Element(elem),
8519 ));
8520 child_idx += 1;
8521 }
8522 #[cfg(not(feature = "extra-children"))]
8523 _ => {}
8524 }
8525 }
8526 Event::End(_) => break,
8527 Event::Eof => break,
8528 _ => {}
8529 }
8530 buf.clear();
8531 }
8532 }
8533
8534 Ok(Self {
8535 name: f_name,
8536 show_as_icon: f_show_as_icon,
8537 img_w: f_img_w,
8538 img_h: f_img_h,
8539 ext_lst: f_ext_lst,
8540 spid: f_spid,
8541 picture: f_picture,
8542 #[cfg(feature = "extra-attrs")]
8543 extra_attrs,
8544 #[cfg(feature = "extra-children")]
8545 extra_children,
8546 })
8547 }
8548}
8549
8550impl FromXml for CTControlList {
8551 fn from_xml<R: BufRead>(
8552 reader: &mut Reader<R>,
8553 start_tag: &BytesStart,
8554 is_empty: bool,
8555 ) -> Result<Self, ParseError> {
8556 let mut f_control = Vec::new();
8557 #[cfg(feature = "extra-children")]
8558 let mut extra_children = Vec::new();
8559 #[cfg(feature = "extra-children")]
8560 let mut child_idx: usize = 0;
8561
8562 if !is_empty {
8564 let mut buf = Vec::new();
8565 loop {
8566 match reader.read_event_into(&mut buf)? {
8567 Event::Start(e) => {
8568 match e.local_name().as_ref() {
8569 b"control" => {
8570 f_control.push(CTControl::from_xml(reader, &e, false)?);
8571 #[cfg(feature = "extra-children")]
8572 {
8573 child_idx += 1;
8574 }
8575 }
8576 #[cfg(feature = "extra-children")]
8577 _ => {
8578 let elem = RawXmlElement::from_reader(reader, &e)?;
8580 extra_children.push(PositionedNode::new(
8581 child_idx,
8582 RawXmlNode::Element(elem),
8583 ));
8584 child_idx += 1;
8585 }
8586 #[cfg(not(feature = "extra-children"))]
8587 _ => {
8588 skip_element(reader)?;
8590 }
8591 }
8592 }
8593 Event::Empty(e) => {
8594 match e.local_name().as_ref() {
8595 b"control" => {
8596 f_control.push(CTControl::from_xml(reader, &e, true)?);
8597 #[cfg(feature = "extra-children")]
8598 {
8599 child_idx += 1;
8600 }
8601 }
8602 #[cfg(feature = "extra-children")]
8603 _ => {
8604 let elem = RawXmlElement::from_empty(&e);
8606 extra_children.push(PositionedNode::new(
8607 child_idx,
8608 RawXmlNode::Element(elem),
8609 ));
8610 child_idx += 1;
8611 }
8612 #[cfg(not(feature = "extra-children"))]
8613 _ => {}
8614 }
8615 }
8616 Event::End(_) => break,
8617 Event::Eof => break,
8618 _ => {}
8619 }
8620 buf.clear();
8621 }
8622 }
8623
8624 Ok(Self {
8625 control: f_control,
8626 #[cfg(feature = "extra-children")]
8627 extra_children,
8628 })
8629 }
8630}
8631
8632impl FromXml for CTSlideIdListEntry {
8633 fn from_xml<R: BufRead>(
8634 reader: &mut Reader<R>,
8635 start_tag: &BytesStart,
8636 is_empty: bool,
8637 ) -> Result<Self, ParseError> {
8638 let mut f_id: Option<STSlideId> = None;
8639 let mut f_ext_lst = None;
8640 #[cfg(feature = "extra-attrs")]
8641 let mut extra_attrs = std::collections::HashMap::new();
8642 #[cfg(feature = "extra-children")]
8643 let mut extra_children = Vec::new();
8644 #[cfg(feature = "extra-children")]
8645 let mut child_idx: usize = 0;
8646
8647 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
8649 let val = String::from_utf8_lossy(&attr.value);
8650 match attr.key.local_name().as_ref() {
8651 b"id" => {
8652 f_id = val.parse().ok();
8653 }
8654 #[cfg(feature = "extra-attrs")]
8655 unknown => {
8656 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
8657 extra_attrs.insert(key, val.into_owned());
8658 }
8659 #[cfg(not(feature = "extra-attrs"))]
8660 _ => {}
8661 }
8662 }
8663
8664 if !is_empty {
8666 let mut buf = Vec::new();
8667 loop {
8668 match reader.read_event_into(&mut buf)? {
8669 Event::Start(e) => {
8670 match e.local_name().as_ref() {
8671 b"extLst" => {
8672 f_ext_lst =
8673 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
8674 #[cfg(feature = "extra-children")]
8675 {
8676 child_idx += 1;
8677 }
8678 }
8679 #[cfg(feature = "extra-children")]
8680 _ => {
8681 let elem = RawXmlElement::from_reader(reader, &e)?;
8683 extra_children.push(PositionedNode::new(
8684 child_idx,
8685 RawXmlNode::Element(elem),
8686 ));
8687 child_idx += 1;
8688 }
8689 #[cfg(not(feature = "extra-children"))]
8690 _ => {
8691 skip_element(reader)?;
8693 }
8694 }
8695 }
8696 Event::Empty(e) => {
8697 match e.local_name().as_ref() {
8698 b"extLst" => {
8699 f_ext_lst =
8700 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
8701 #[cfg(feature = "extra-children")]
8702 {
8703 child_idx += 1;
8704 }
8705 }
8706 #[cfg(feature = "extra-children")]
8707 _ => {
8708 let elem = RawXmlElement::from_empty(&e);
8710 extra_children.push(PositionedNode::new(
8711 child_idx,
8712 RawXmlNode::Element(elem),
8713 ));
8714 child_idx += 1;
8715 }
8716 #[cfg(not(feature = "extra-children"))]
8717 _ => {}
8718 }
8719 }
8720 Event::End(_) => break,
8721 Event::Eof => break,
8722 _ => {}
8723 }
8724 buf.clear();
8725 }
8726 }
8727
8728 Ok(Self {
8729 id: f_id.ok_or_else(|| ParseError::MissingAttribute("id".to_string()))?,
8730 ext_lst: f_ext_lst,
8731 #[cfg(feature = "extra-attrs")]
8732 extra_attrs,
8733 #[cfg(feature = "extra-children")]
8734 extra_children,
8735 })
8736 }
8737}
8738
8739impl FromXml for SlideIdList {
8740 fn from_xml<R: BufRead>(
8741 reader: &mut Reader<R>,
8742 start_tag: &BytesStart,
8743 is_empty: bool,
8744 ) -> Result<Self, ParseError> {
8745 let mut f_sld_id = Vec::new();
8746 #[cfg(feature = "extra-children")]
8747 let mut extra_children = Vec::new();
8748 #[cfg(feature = "extra-children")]
8749 let mut child_idx: usize = 0;
8750
8751 if !is_empty {
8753 let mut buf = Vec::new();
8754 loop {
8755 match reader.read_event_into(&mut buf)? {
8756 Event::Start(e) => {
8757 match e.local_name().as_ref() {
8758 b"sldId" => {
8759 f_sld_id.push(CTSlideIdListEntry::from_xml(reader, &e, false)?);
8760 #[cfg(feature = "extra-children")]
8761 {
8762 child_idx += 1;
8763 }
8764 }
8765 #[cfg(feature = "extra-children")]
8766 _ => {
8767 let elem = RawXmlElement::from_reader(reader, &e)?;
8769 extra_children.push(PositionedNode::new(
8770 child_idx,
8771 RawXmlNode::Element(elem),
8772 ));
8773 child_idx += 1;
8774 }
8775 #[cfg(not(feature = "extra-children"))]
8776 _ => {
8777 skip_element(reader)?;
8779 }
8780 }
8781 }
8782 Event::Empty(e) => {
8783 match e.local_name().as_ref() {
8784 b"sldId" => {
8785 f_sld_id.push(CTSlideIdListEntry::from_xml(reader, &e, true)?);
8786 #[cfg(feature = "extra-children")]
8787 {
8788 child_idx += 1;
8789 }
8790 }
8791 #[cfg(feature = "extra-children")]
8792 _ => {
8793 let elem = RawXmlElement::from_empty(&e);
8795 extra_children.push(PositionedNode::new(
8796 child_idx,
8797 RawXmlNode::Element(elem),
8798 ));
8799 child_idx += 1;
8800 }
8801 #[cfg(not(feature = "extra-children"))]
8802 _ => {}
8803 }
8804 }
8805 Event::End(_) => break,
8806 Event::Eof => break,
8807 _ => {}
8808 }
8809 buf.clear();
8810 }
8811 }
8812
8813 Ok(Self {
8814 sld_id: f_sld_id,
8815 #[cfg(feature = "extra-children")]
8816 extra_children,
8817 })
8818 }
8819}
8820
8821impl FromXml for CTSlideMasterIdListEntry {
8822 fn from_xml<R: BufRead>(
8823 reader: &mut Reader<R>,
8824 start_tag: &BytesStart,
8825 is_empty: bool,
8826 ) -> Result<Self, ParseError> {
8827 let mut f_id = None;
8828 let mut f_ext_lst = None;
8829 #[cfg(feature = "extra-attrs")]
8830 let mut extra_attrs = std::collections::HashMap::new();
8831 #[cfg(feature = "extra-children")]
8832 let mut extra_children = Vec::new();
8833 #[cfg(feature = "extra-children")]
8834 let mut child_idx: usize = 0;
8835
8836 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
8838 let val = String::from_utf8_lossy(&attr.value);
8839 match attr.key.local_name().as_ref() {
8840 b"id" => {
8841 f_id = val.parse().ok();
8842 }
8843 #[cfg(feature = "extra-attrs")]
8844 unknown => {
8845 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
8846 extra_attrs.insert(key, val.into_owned());
8847 }
8848 #[cfg(not(feature = "extra-attrs"))]
8849 _ => {}
8850 }
8851 }
8852
8853 if !is_empty {
8855 let mut buf = Vec::new();
8856 loop {
8857 match reader.read_event_into(&mut buf)? {
8858 Event::Start(e) => {
8859 match e.local_name().as_ref() {
8860 b"extLst" => {
8861 f_ext_lst =
8862 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
8863 #[cfg(feature = "extra-children")]
8864 {
8865 child_idx += 1;
8866 }
8867 }
8868 #[cfg(feature = "extra-children")]
8869 _ => {
8870 let elem = RawXmlElement::from_reader(reader, &e)?;
8872 extra_children.push(PositionedNode::new(
8873 child_idx,
8874 RawXmlNode::Element(elem),
8875 ));
8876 child_idx += 1;
8877 }
8878 #[cfg(not(feature = "extra-children"))]
8879 _ => {
8880 skip_element(reader)?;
8882 }
8883 }
8884 }
8885 Event::Empty(e) => {
8886 match e.local_name().as_ref() {
8887 b"extLst" => {
8888 f_ext_lst =
8889 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
8890 #[cfg(feature = "extra-children")]
8891 {
8892 child_idx += 1;
8893 }
8894 }
8895 #[cfg(feature = "extra-children")]
8896 _ => {
8897 let elem = RawXmlElement::from_empty(&e);
8899 extra_children.push(PositionedNode::new(
8900 child_idx,
8901 RawXmlNode::Element(elem),
8902 ));
8903 child_idx += 1;
8904 }
8905 #[cfg(not(feature = "extra-children"))]
8906 _ => {}
8907 }
8908 }
8909 Event::End(_) => break,
8910 Event::Eof => break,
8911 _ => {}
8912 }
8913 buf.clear();
8914 }
8915 }
8916
8917 Ok(Self {
8918 id: f_id,
8919 ext_lst: f_ext_lst,
8920 #[cfg(feature = "extra-attrs")]
8921 extra_attrs,
8922 #[cfg(feature = "extra-children")]
8923 extra_children,
8924 })
8925 }
8926}
8927
8928impl FromXml for CTSlideMasterIdList {
8929 fn from_xml<R: BufRead>(
8930 reader: &mut Reader<R>,
8931 start_tag: &BytesStart,
8932 is_empty: bool,
8933 ) -> Result<Self, ParseError> {
8934 let mut f_sld_master_id = Vec::new();
8935 #[cfg(feature = "extra-children")]
8936 let mut extra_children = Vec::new();
8937 #[cfg(feature = "extra-children")]
8938 let mut child_idx: usize = 0;
8939
8940 if !is_empty {
8942 let mut buf = Vec::new();
8943 loop {
8944 match reader.read_event_into(&mut buf)? {
8945 Event::Start(e) => {
8946 match e.local_name().as_ref() {
8947 b"sldMasterId" => {
8948 f_sld_master_id
8949 .push(CTSlideMasterIdListEntry::from_xml(reader, &e, false)?);
8950 #[cfg(feature = "extra-children")]
8951 {
8952 child_idx += 1;
8953 }
8954 }
8955 #[cfg(feature = "extra-children")]
8956 _ => {
8957 let elem = RawXmlElement::from_reader(reader, &e)?;
8959 extra_children.push(PositionedNode::new(
8960 child_idx,
8961 RawXmlNode::Element(elem),
8962 ));
8963 child_idx += 1;
8964 }
8965 #[cfg(not(feature = "extra-children"))]
8966 _ => {
8967 skip_element(reader)?;
8969 }
8970 }
8971 }
8972 Event::Empty(e) => {
8973 match e.local_name().as_ref() {
8974 b"sldMasterId" => {
8975 f_sld_master_id
8976 .push(CTSlideMasterIdListEntry::from_xml(reader, &e, true)?);
8977 #[cfg(feature = "extra-children")]
8978 {
8979 child_idx += 1;
8980 }
8981 }
8982 #[cfg(feature = "extra-children")]
8983 _ => {
8984 let elem = RawXmlElement::from_empty(&e);
8986 extra_children.push(PositionedNode::new(
8987 child_idx,
8988 RawXmlNode::Element(elem),
8989 ));
8990 child_idx += 1;
8991 }
8992 #[cfg(not(feature = "extra-children"))]
8993 _ => {}
8994 }
8995 }
8996 Event::End(_) => break,
8997 Event::Eof => break,
8998 _ => {}
8999 }
9000 buf.clear();
9001 }
9002 }
9003
9004 Ok(Self {
9005 sld_master_id: f_sld_master_id,
9006 #[cfg(feature = "extra-children")]
9007 extra_children,
9008 })
9009 }
9010}
9011
9012impl FromXml for CTNotesMasterIdListEntry {
9013 fn from_xml<R: BufRead>(
9014 reader: &mut Reader<R>,
9015 start_tag: &BytesStart,
9016 is_empty: bool,
9017 ) -> Result<Self, ParseError> {
9018 let mut f_ext_lst = None;
9019 #[cfg(feature = "extra-children")]
9020 let mut extra_children = Vec::new();
9021 #[cfg(feature = "extra-children")]
9022 let mut child_idx: usize = 0;
9023
9024 if !is_empty {
9026 let mut buf = Vec::new();
9027 loop {
9028 match reader.read_event_into(&mut buf)? {
9029 Event::Start(e) => {
9030 match e.local_name().as_ref() {
9031 b"extLst" => {
9032 f_ext_lst =
9033 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
9034 #[cfg(feature = "extra-children")]
9035 {
9036 child_idx += 1;
9037 }
9038 }
9039 #[cfg(feature = "extra-children")]
9040 _ => {
9041 let elem = RawXmlElement::from_reader(reader, &e)?;
9043 extra_children.push(PositionedNode::new(
9044 child_idx,
9045 RawXmlNode::Element(elem),
9046 ));
9047 child_idx += 1;
9048 }
9049 #[cfg(not(feature = "extra-children"))]
9050 _ => {
9051 skip_element(reader)?;
9053 }
9054 }
9055 }
9056 Event::Empty(e) => {
9057 match e.local_name().as_ref() {
9058 b"extLst" => {
9059 f_ext_lst =
9060 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
9061 #[cfg(feature = "extra-children")]
9062 {
9063 child_idx += 1;
9064 }
9065 }
9066 #[cfg(feature = "extra-children")]
9067 _ => {
9068 let elem = RawXmlElement::from_empty(&e);
9070 extra_children.push(PositionedNode::new(
9071 child_idx,
9072 RawXmlNode::Element(elem),
9073 ));
9074 child_idx += 1;
9075 }
9076 #[cfg(not(feature = "extra-children"))]
9077 _ => {}
9078 }
9079 }
9080 Event::End(_) => break,
9081 Event::Eof => break,
9082 _ => {}
9083 }
9084 buf.clear();
9085 }
9086 }
9087
9088 Ok(Self {
9089 ext_lst: f_ext_lst,
9090 #[cfg(feature = "extra-children")]
9091 extra_children,
9092 })
9093 }
9094}
9095
9096impl FromXml for CTNotesMasterIdList {
9097 fn from_xml<R: BufRead>(
9098 reader: &mut Reader<R>,
9099 start_tag: &BytesStart,
9100 is_empty: bool,
9101 ) -> Result<Self, ParseError> {
9102 let mut f_notes_master_id = None;
9103 #[cfg(feature = "extra-children")]
9104 let mut extra_children = Vec::new();
9105 #[cfg(feature = "extra-children")]
9106 let mut child_idx: usize = 0;
9107
9108 if !is_empty {
9110 let mut buf = Vec::new();
9111 loop {
9112 match reader.read_event_into(&mut buf)? {
9113 Event::Start(e) => {
9114 match e.local_name().as_ref() {
9115 b"notesMasterId" => {
9116 f_notes_master_id = Some(Box::new(
9117 CTNotesMasterIdListEntry::from_xml(reader, &e, false)?,
9118 ));
9119 #[cfg(feature = "extra-children")]
9120 {
9121 child_idx += 1;
9122 }
9123 }
9124 #[cfg(feature = "extra-children")]
9125 _ => {
9126 let elem = RawXmlElement::from_reader(reader, &e)?;
9128 extra_children.push(PositionedNode::new(
9129 child_idx,
9130 RawXmlNode::Element(elem),
9131 ));
9132 child_idx += 1;
9133 }
9134 #[cfg(not(feature = "extra-children"))]
9135 _ => {
9136 skip_element(reader)?;
9138 }
9139 }
9140 }
9141 Event::Empty(e) => {
9142 match e.local_name().as_ref() {
9143 b"notesMasterId" => {
9144 f_notes_master_id = Some(Box::new(
9145 CTNotesMasterIdListEntry::from_xml(reader, &e, true)?,
9146 ));
9147 #[cfg(feature = "extra-children")]
9148 {
9149 child_idx += 1;
9150 }
9151 }
9152 #[cfg(feature = "extra-children")]
9153 _ => {
9154 let elem = RawXmlElement::from_empty(&e);
9156 extra_children.push(PositionedNode::new(
9157 child_idx,
9158 RawXmlNode::Element(elem),
9159 ));
9160 child_idx += 1;
9161 }
9162 #[cfg(not(feature = "extra-children"))]
9163 _ => {}
9164 }
9165 }
9166 Event::End(_) => break,
9167 Event::Eof => break,
9168 _ => {}
9169 }
9170 buf.clear();
9171 }
9172 }
9173
9174 Ok(Self {
9175 notes_master_id: f_notes_master_id,
9176 #[cfg(feature = "extra-children")]
9177 extra_children,
9178 })
9179 }
9180}
9181
9182impl FromXml for CTHandoutMasterIdListEntry {
9183 fn from_xml<R: BufRead>(
9184 reader: &mut Reader<R>,
9185 start_tag: &BytesStart,
9186 is_empty: bool,
9187 ) -> Result<Self, ParseError> {
9188 let mut f_ext_lst = None;
9189 #[cfg(feature = "extra-children")]
9190 let mut extra_children = Vec::new();
9191 #[cfg(feature = "extra-children")]
9192 let mut child_idx: usize = 0;
9193
9194 if !is_empty {
9196 let mut buf = Vec::new();
9197 loop {
9198 match reader.read_event_into(&mut buf)? {
9199 Event::Start(e) => {
9200 match e.local_name().as_ref() {
9201 b"extLst" => {
9202 f_ext_lst =
9203 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
9204 #[cfg(feature = "extra-children")]
9205 {
9206 child_idx += 1;
9207 }
9208 }
9209 #[cfg(feature = "extra-children")]
9210 _ => {
9211 let elem = RawXmlElement::from_reader(reader, &e)?;
9213 extra_children.push(PositionedNode::new(
9214 child_idx,
9215 RawXmlNode::Element(elem),
9216 ));
9217 child_idx += 1;
9218 }
9219 #[cfg(not(feature = "extra-children"))]
9220 _ => {
9221 skip_element(reader)?;
9223 }
9224 }
9225 }
9226 Event::Empty(e) => {
9227 match e.local_name().as_ref() {
9228 b"extLst" => {
9229 f_ext_lst =
9230 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
9231 #[cfg(feature = "extra-children")]
9232 {
9233 child_idx += 1;
9234 }
9235 }
9236 #[cfg(feature = "extra-children")]
9237 _ => {
9238 let elem = RawXmlElement::from_empty(&e);
9240 extra_children.push(PositionedNode::new(
9241 child_idx,
9242 RawXmlNode::Element(elem),
9243 ));
9244 child_idx += 1;
9245 }
9246 #[cfg(not(feature = "extra-children"))]
9247 _ => {}
9248 }
9249 }
9250 Event::End(_) => break,
9251 Event::Eof => break,
9252 _ => {}
9253 }
9254 buf.clear();
9255 }
9256 }
9257
9258 Ok(Self {
9259 ext_lst: f_ext_lst,
9260 #[cfg(feature = "extra-children")]
9261 extra_children,
9262 })
9263 }
9264}
9265
9266impl FromXml for CTHandoutMasterIdList {
9267 fn from_xml<R: BufRead>(
9268 reader: &mut Reader<R>,
9269 start_tag: &BytesStart,
9270 is_empty: bool,
9271 ) -> Result<Self, ParseError> {
9272 let mut f_handout_master_id = None;
9273 #[cfg(feature = "extra-children")]
9274 let mut extra_children = Vec::new();
9275 #[cfg(feature = "extra-children")]
9276 let mut child_idx: usize = 0;
9277
9278 if !is_empty {
9280 let mut buf = Vec::new();
9281 loop {
9282 match reader.read_event_into(&mut buf)? {
9283 Event::Start(e) => {
9284 match e.local_name().as_ref() {
9285 b"handoutMasterId" => {
9286 f_handout_master_id = Some(Box::new(
9287 CTHandoutMasterIdListEntry::from_xml(reader, &e, false)?,
9288 ));
9289 #[cfg(feature = "extra-children")]
9290 {
9291 child_idx += 1;
9292 }
9293 }
9294 #[cfg(feature = "extra-children")]
9295 _ => {
9296 let elem = RawXmlElement::from_reader(reader, &e)?;
9298 extra_children.push(PositionedNode::new(
9299 child_idx,
9300 RawXmlNode::Element(elem),
9301 ));
9302 child_idx += 1;
9303 }
9304 #[cfg(not(feature = "extra-children"))]
9305 _ => {
9306 skip_element(reader)?;
9308 }
9309 }
9310 }
9311 Event::Empty(e) => {
9312 match e.local_name().as_ref() {
9313 b"handoutMasterId" => {
9314 f_handout_master_id = Some(Box::new(
9315 CTHandoutMasterIdListEntry::from_xml(reader, &e, true)?,
9316 ));
9317 #[cfg(feature = "extra-children")]
9318 {
9319 child_idx += 1;
9320 }
9321 }
9322 #[cfg(feature = "extra-children")]
9323 _ => {
9324 let elem = RawXmlElement::from_empty(&e);
9326 extra_children.push(PositionedNode::new(
9327 child_idx,
9328 RawXmlNode::Element(elem),
9329 ));
9330 child_idx += 1;
9331 }
9332 #[cfg(not(feature = "extra-children"))]
9333 _ => {}
9334 }
9335 }
9336 Event::End(_) => break,
9337 Event::Eof => break,
9338 _ => {}
9339 }
9340 buf.clear();
9341 }
9342 }
9343
9344 Ok(Self {
9345 handout_master_id: f_handout_master_id,
9346 #[cfg(feature = "extra-children")]
9347 extra_children,
9348 })
9349 }
9350}
9351
9352impl FromXml for CTEmbeddedFontDataId {
9353 fn from_xml<R: BufRead>(
9354 reader: &mut Reader<R>,
9355 start_tag: &BytesStart,
9356 is_empty: bool,
9357 ) -> Result<Self, ParseError> {
9358 #[cfg(feature = "extra-children")]
9359 let mut extra_children = Vec::new();
9360 #[cfg(feature = "extra-children")]
9361 let mut child_idx: usize = 0;
9362 if !is_empty {
9363 let mut buf = Vec::new();
9364 loop {
9365 match reader.read_event_into(&mut buf)? {
9366 #[cfg(feature = "extra-children")]
9367 Event::Start(e) => {
9368 let elem = RawXmlElement::from_reader(reader, &e)?;
9369 extra_children
9370 .push(PositionedNode::new(child_idx, RawXmlNode::Element(elem)));
9371 child_idx += 1;
9372 }
9373 #[cfg(not(feature = "extra-children"))]
9374 Event::Start(_) => {
9375 skip_element(reader)?;
9376 }
9377 #[cfg(feature = "extra-children")]
9378 Event::Empty(e) => {
9379 let elem = RawXmlElement::from_empty(&e);
9380 extra_children
9381 .push(PositionedNode::new(child_idx, RawXmlNode::Element(elem)));
9382 child_idx += 1;
9383 }
9384 #[cfg(not(feature = "extra-children"))]
9385 Event::Empty(_) => {}
9386 Event::End(_) => break,
9387 Event::Eof => break,
9388 _ => {}
9389 }
9390 buf.clear();
9391 }
9392 }
9393 Ok(Self {
9394 #[cfg(feature = "extra-children")]
9395 extra_children,
9396 })
9397 }
9398}
9399
9400impl FromXml for CTEmbeddedFontListEntry {
9401 fn from_xml<R: BufRead>(
9402 reader: &mut Reader<R>,
9403 start_tag: &BytesStart,
9404 is_empty: bool,
9405 ) -> Result<Self, ParseError> {
9406 let mut f_font: Option<Box<ooxml_dml::types::TextFont>> = None;
9407 let mut f_regular = None;
9408 let mut f_bold = None;
9409 let mut f_italic = None;
9410 let mut f_bold_italic = None;
9411 #[cfg(feature = "extra-children")]
9412 let mut extra_children = Vec::new();
9413 #[cfg(feature = "extra-children")]
9414 let mut child_idx: usize = 0;
9415
9416 if !is_empty {
9418 let mut buf = Vec::new();
9419 loop {
9420 match reader.read_event_into(&mut buf)? {
9421 Event::Start(e) => {
9422 match e.local_name().as_ref() {
9423 b"font" => {
9424 f_font = Some(Box::new(ooxml_dml::types::TextFont::from_xml(
9425 reader, &e, false,
9426 )?));
9427 #[cfg(feature = "extra-children")]
9428 {
9429 child_idx += 1;
9430 }
9431 }
9432 b"regular" => {
9433 f_regular = Some(Box::new(CTEmbeddedFontDataId::from_xml(
9434 reader, &e, false,
9435 )?));
9436 #[cfg(feature = "extra-children")]
9437 {
9438 child_idx += 1;
9439 }
9440 }
9441 b"bold" => {
9442 f_bold = Some(Box::new(CTEmbeddedFontDataId::from_xml(
9443 reader, &e, false,
9444 )?));
9445 #[cfg(feature = "extra-children")]
9446 {
9447 child_idx += 1;
9448 }
9449 }
9450 b"italic" => {
9451 f_italic = Some(Box::new(CTEmbeddedFontDataId::from_xml(
9452 reader, &e, false,
9453 )?));
9454 #[cfg(feature = "extra-children")]
9455 {
9456 child_idx += 1;
9457 }
9458 }
9459 b"boldItalic" => {
9460 f_bold_italic = Some(Box::new(CTEmbeddedFontDataId::from_xml(
9461 reader, &e, false,
9462 )?));
9463 #[cfg(feature = "extra-children")]
9464 {
9465 child_idx += 1;
9466 }
9467 }
9468 #[cfg(feature = "extra-children")]
9469 _ => {
9470 let elem = RawXmlElement::from_reader(reader, &e)?;
9472 extra_children.push(PositionedNode::new(
9473 child_idx,
9474 RawXmlNode::Element(elem),
9475 ));
9476 child_idx += 1;
9477 }
9478 #[cfg(not(feature = "extra-children"))]
9479 _ => {
9480 skip_element(reader)?;
9482 }
9483 }
9484 }
9485 Event::Empty(e) => {
9486 match e.local_name().as_ref() {
9487 b"font" => {
9488 f_font = Some(Box::new(ooxml_dml::types::TextFont::from_xml(
9489 reader, &e, true,
9490 )?));
9491 #[cfg(feature = "extra-children")]
9492 {
9493 child_idx += 1;
9494 }
9495 }
9496 b"regular" => {
9497 f_regular = Some(Box::new(CTEmbeddedFontDataId::from_xml(
9498 reader, &e, true,
9499 )?));
9500 #[cfg(feature = "extra-children")]
9501 {
9502 child_idx += 1;
9503 }
9504 }
9505 b"bold" => {
9506 f_bold = Some(Box::new(CTEmbeddedFontDataId::from_xml(
9507 reader, &e, true,
9508 )?));
9509 #[cfg(feature = "extra-children")]
9510 {
9511 child_idx += 1;
9512 }
9513 }
9514 b"italic" => {
9515 f_italic = Some(Box::new(CTEmbeddedFontDataId::from_xml(
9516 reader, &e, true,
9517 )?));
9518 #[cfg(feature = "extra-children")]
9519 {
9520 child_idx += 1;
9521 }
9522 }
9523 b"boldItalic" => {
9524 f_bold_italic = Some(Box::new(CTEmbeddedFontDataId::from_xml(
9525 reader, &e, true,
9526 )?));
9527 #[cfg(feature = "extra-children")]
9528 {
9529 child_idx += 1;
9530 }
9531 }
9532 #[cfg(feature = "extra-children")]
9533 _ => {
9534 let elem = RawXmlElement::from_empty(&e);
9536 extra_children.push(PositionedNode::new(
9537 child_idx,
9538 RawXmlNode::Element(elem),
9539 ));
9540 child_idx += 1;
9541 }
9542 #[cfg(not(feature = "extra-children"))]
9543 _ => {}
9544 }
9545 }
9546 Event::End(_) => break,
9547 Event::Eof => break,
9548 _ => {}
9549 }
9550 buf.clear();
9551 }
9552 }
9553
9554 Ok(Self {
9555 font: f_font.ok_or_else(|| ParseError::MissingAttribute("font".to_string()))?,
9556 regular: f_regular,
9557 bold: f_bold,
9558 italic: f_italic,
9559 bold_italic: f_bold_italic,
9560 #[cfg(feature = "extra-children")]
9561 extra_children,
9562 })
9563 }
9564}
9565
9566impl FromXml for CTEmbeddedFontList {
9567 fn from_xml<R: BufRead>(
9568 reader: &mut Reader<R>,
9569 start_tag: &BytesStart,
9570 is_empty: bool,
9571 ) -> Result<Self, ParseError> {
9572 let mut f_embedded_font = Vec::new();
9573 #[cfg(feature = "extra-children")]
9574 let mut extra_children = Vec::new();
9575 #[cfg(feature = "extra-children")]
9576 let mut child_idx: usize = 0;
9577
9578 if !is_empty {
9580 let mut buf = Vec::new();
9581 loop {
9582 match reader.read_event_into(&mut buf)? {
9583 Event::Start(e) => {
9584 match e.local_name().as_ref() {
9585 b"embeddedFont" => {
9586 f_embedded_font
9587 .push(CTEmbeddedFontListEntry::from_xml(reader, &e, false)?);
9588 #[cfg(feature = "extra-children")]
9589 {
9590 child_idx += 1;
9591 }
9592 }
9593 #[cfg(feature = "extra-children")]
9594 _ => {
9595 let elem = RawXmlElement::from_reader(reader, &e)?;
9597 extra_children.push(PositionedNode::new(
9598 child_idx,
9599 RawXmlNode::Element(elem),
9600 ));
9601 child_idx += 1;
9602 }
9603 #[cfg(not(feature = "extra-children"))]
9604 _ => {
9605 skip_element(reader)?;
9607 }
9608 }
9609 }
9610 Event::Empty(e) => {
9611 match e.local_name().as_ref() {
9612 b"embeddedFont" => {
9613 f_embedded_font
9614 .push(CTEmbeddedFontListEntry::from_xml(reader, &e, true)?);
9615 #[cfg(feature = "extra-children")]
9616 {
9617 child_idx += 1;
9618 }
9619 }
9620 #[cfg(feature = "extra-children")]
9621 _ => {
9622 let elem = RawXmlElement::from_empty(&e);
9624 extra_children.push(PositionedNode::new(
9625 child_idx,
9626 RawXmlNode::Element(elem),
9627 ));
9628 child_idx += 1;
9629 }
9630 #[cfg(not(feature = "extra-children"))]
9631 _ => {}
9632 }
9633 }
9634 Event::End(_) => break,
9635 Event::Eof => break,
9636 _ => {}
9637 }
9638 buf.clear();
9639 }
9640 }
9641
9642 Ok(Self {
9643 embedded_font: f_embedded_font,
9644 #[cfg(feature = "extra-children")]
9645 extra_children,
9646 })
9647 }
9648}
9649
9650impl FromXml for CTSmartTags {
9651 fn from_xml<R: BufRead>(
9652 reader: &mut Reader<R>,
9653 start_tag: &BytesStart,
9654 is_empty: bool,
9655 ) -> Result<Self, ParseError> {
9656 #[cfg(feature = "extra-children")]
9657 let mut extra_children = Vec::new();
9658 #[cfg(feature = "extra-children")]
9659 let mut child_idx: usize = 0;
9660 if !is_empty {
9661 let mut buf = Vec::new();
9662 loop {
9663 match reader.read_event_into(&mut buf)? {
9664 #[cfg(feature = "extra-children")]
9665 Event::Start(e) => {
9666 let elem = RawXmlElement::from_reader(reader, &e)?;
9667 extra_children
9668 .push(PositionedNode::new(child_idx, RawXmlNode::Element(elem)));
9669 child_idx += 1;
9670 }
9671 #[cfg(not(feature = "extra-children"))]
9672 Event::Start(_) => {
9673 skip_element(reader)?;
9674 }
9675 #[cfg(feature = "extra-children")]
9676 Event::Empty(e) => {
9677 let elem = RawXmlElement::from_empty(&e);
9678 extra_children
9679 .push(PositionedNode::new(child_idx, RawXmlNode::Element(elem)));
9680 child_idx += 1;
9681 }
9682 #[cfg(not(feature = "extra-children"))]
9683 Event::Empty(_) => {}
9684 Event::End(_) => break,
9685 Event::Eof => break,
9686 _ => {}
9687 }
9688 buf.clear();
9689 }
9690 }
9691 Ok(Self {
9692 #[cfg(feature = "extra-children")]
9693 extra_children,
9694 })
9695 }
9696}
9697
9698impl FromXml for CTCustomShow {
9699 fn from_xml<R: BufRead>(
9700 reader: &mut Reader<R>,
9701 start_tag: &BytesStart,
9702 is_empty: bool,
9703 ) -> Result<Self, ParseError> {
9704 let mut f_name: Option<STName> = None;
9705 let mut f_id: Option<u32> = None;
9706 let mut f_sld_lst: Option<Box<CTSlideRelationshipList>> = None;
9707 let mut f_ext_lst = None;
9708 #[cfg(feature = "extra-attrs")]
9709 let mut extra_attrs = std::collections::HashMap::new();
9710 #[cfg(feature = "extra-children")]
9711 let mut extra_children = Vec::new();
9712 #[cfg(feature = "extra-children")]
9713 let mut child_idx: usize = 0;
9714
9715 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
9717 let val = String::from_utf8_lossy(&attr.value);
9718 match attr.key.local_name().as_ref() {
9719 b"name" => {
9720 f_name = Some(val.into_owned());
9721 }
9722 b"id" => {
9723 f_id = val.parse().ok();
9724 }
9725 #[cfg(feature = "extra-attrs")]
9726 unknown => {
9727 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
9728 extra_attrs.insert(key, val.into_owned());
9729 }
9730 #[cfg(not(feature = "extra-attrs"))]
9731 _ => {}
9732 }
9733 }
9734
9735 if !is_empty {
9737 let mut buf = Vec::new();
9738 loop {
9739 match reader.read_event_into(&mut buf)? {
9740 Event::Start(e) => {
9741 match e.local_name().as_ref() {
9742 b"sldLst" => {
9743 f_sld_lst = Some(Box::new(CTSlideRelationshipList::from_xml(
9744 reader, &e, false,
9745 )?));
9746 #[cfg(feature = "extra-children")]
9747 {
9748 child_idx += 1;
9749 }
9750 }
9751 b"extLst" => {
9752 f_ext_lst =
9753 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
9754 #[cfg(feature = "extra-children")]
9755 {
9756 child_idx += 1;
9757 }
9758 }
9759 #[cfg(feature = "extra-children")]
9760 _ => {
9761 let elem = RawXmlElement::from_reader(reader, &e)?;
9763 extra_children.push(PositionedNode::new(
9764 child_idx,
9765 RawXmlNode::Element(elem),
9766 ));
9767 child_idx += 1;
9768 }
9769 #[cfg(not(feature = "extra-children"))]
9770 _ => {
9771 skip_element(reader)?;
9773 }
9774 }
9775 }
9776 Event::Empty(e) => {
9777 match e.local_name().as_ref() {
9778 b"sldLst" => {
9779 f_sld_lst = Some(Box::new(CTSlideRelationshipList::from_xml(
9780 reader, &e, true,
9781 )?));
9782 #[cfg(feature = "extra-children")]
9783 {
9784 child_idx += 1;
9785 }
9786 }
9787 b"extLst" => {
9788 f_ext_lst =
9789 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
9790 #[cfg(feature = "extra-children")]
9791 {
9792 child_idx += 1;
9793 }
9794 }
9795 #[cfg(feature = "extra-children")]
9796 _ => {
9797 let elem = RawXmlElement::from_empty(&e);
9799 extra_children.push(PositionedNode::new(
9800 child_idx,
9801 RawXmlNode::Element(elem),
9802 ));
9803 child_idx += 1;
9804 }
9805 #[cfg(not(feature = "extra-children"))]
9806 _ => {}
9807 }
9808 }
9809 Event::End(_) => break,
9810 Event::Eof => break,
9811 _ => {}
9812 }
9813 buf.clear();
9814 }
9815 }
9816
9817 Ok(Self {
9818 name: f_name.ok_or_else(|| ParseError::MissingAttribute("name".to_string()))?,
9819 id: f_id.ok_or_else(|| ParseError::MissingAttribute("id".to_string()))?,
9820 sld_lst: f_sld_lst.ok_or_else(|| ParseError::MissingAttribute("sldLst".to_string()))?,
9821 ext_lst: f_ext_lst,
9822 #[cfg(feature = "extra-attrs")]
9823 extra_attrs,
9824 #[cfg(feature = "extra-children")]
9825 extra_children,
9826 })
9827 }
9828}
9829
9830impl FromXml for CTCustomShowList {
9831 fn from_xml<R: BufRead>(
9832 reader: &mut Reader<R>,
9833 start_tag: &BytesStart,
9834 is_empty: bool,
9835 ) -> Result<Self, ParseError> {
9836 let mut f_cust_show = Vec::new();
9837 #[cfg(feature = "extra-children")]
9838 let mut extra_children = Vec::new();
9839 #[cfg(feature = "extra-children")]
9840 let mut child_idx: usize = 0;
9841
9842 if !is_empty {
9844 let mut buf = Vec::new();
9845 loop {
9846 match reader.read_event_into(&mut buf)? {
9847 Event::Start(e) => {
9848 match e.local_name().as_ref() {
9849 b"custShow" => {
9850 f_cust_show.push(CTCustomShow::from_xml(reader, &e, false)?);
9851 #[cfg(feature = "extra-children")]
9852 {
9853 child_idx += 1;
9854 }
9855 }
9856 #[cfg(feature = "extra-children")]
9857 _ => {
9858 let elem = RawXmlElement::from_reader(reader, &e)?;
9860 extra_children.push(PositionedNode::new(
9861 child_idx,
9862 RawXmlNode::Element(elem),
9863 ));
9864 child_idx += 1;
9865 }
9866 #[cfg(not(feature = "extra-children"))]
9867 _ => {
9868 skip_element(reader)?;
9870 }
9871 }
9872 }
9873 Event::Empty(e) => {
9874 match e.local_name().as_ref() {
9875 b"custShow" => {
9876 f_cust_show.push(CTCustomShow::from_xml(reader, &e, true)?);
9877 #[cfg(feature = "extra-children")]
9878 {
9879 child_idx += 1;
9880 }
9881 }
9882 #[cfg(feature = "extra-children")]
9883 _ => {
9884 let elem = RawXmlElement::from_empty(&e);
9886 extra_children.push(PositionedNode::new(
9887 child_idx,
9888 RawXmlNode::Element(elem),
9889 ));
9890 child_idx += 1;
9891 }
9892 #[cfg(not(feature = "extra-children"))]
9893 _ => {}
9894 }
9895 }
9896 Event::End(_) => break,
9897 Event::Eof => break,
9898 _ => {}
9899 }
9900 buf.clear();
9901 }
9902 }
9903
9904 Ok(Self {
9905 cust_show: f_cust_show,
9906 #[cfg(feature = "extra-children")]
9907 extra_children,
9908 })
9909 }
9910}
9911
9912impl FromXml for CTPhotoAlbum {
9913 fn from_xml<R: BufRead>(
9914 reader: &mut Reader<R>,
9915 start_tag: &BytesStart,
9916 is_empty: bool,
9917 ) -> Result<Self, ParseError> {
9918 let mut f_bw = None;
9919 let mut f_show_captions = None;
9920 let mut f_layout = None;
9921 let mut f_frame = None;
9922 let mut f_ext_lst = None;
9923 #[cfg(feature = "extra-attrs")]
9924 let mut extra_attrs = std::collections::HashMap::new();
9925 #[cfg(feature = "extra-children")]
9926 let mut extra_children = Vec::new();
9927 #[cfg(feature = "extra-children")]
9928 let mut child_idx: usize = 0;
9929
9930 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
9932 let val = String::from_utf8_lossy(&attr.value);
9933 match attr.key.local_name().as_ref() {
9934 b"bw" => {
9935 f_bw = Some(val == "true" || val == "1");
9936 }
9937 b"showCaptions" => {
9938 f_show_captions = Some(val == "true" || val == "1");
9939 }
9940 b"layout" => {
9941 f_layout = val.parse().ok();
9942 }
9943 b"frame" => {
9944 f_frame = val.parse().ok();
9945 }
9946 #[cfg(feature = "extra-attrs")]
9947 unknown => {
9948 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
9949 extra_attrs.insert(key, val.into_owned());
9950 }
9951 #[cfg(not(feature = "extra-attrs"))]
9952 _ => {}
9953 }
9954 }
9955
9956 if !is_empty {
9958 let mut buf = Vec::new();
9959 loop {
9960 match reader.read_event_into(&mut buf)? {
9961 Event::Start(e) => {
9962 match e.local_name().as_ref() {
9963 b"extLst" => {
9964 f_ext_lst =
9965 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
9966 #[cfg(feature = "extra-children")]
9967 {
9968 child_idx += 1;
9969 }
9970 }
9971 #[cfg(feature = "extra-children")]
9972 _ => {
9973 let elem = RawXmlElement::from_reader(reader, &e)?;
9975 extra_children.push(PositionedNode::new(
9976 child_idx,
9977 RawXmlNode::Element(elem),
9978 ));
9979 child_idx += 1;
9980 }
9981 #[cfg(not(feature = "extra-children"))]
9982 _ => {
9983 skip_element(reader)?;
9985 }
9986 }
9987 }
9988 Event::Empty(e) => {
9989 match e.local_name().as_ref() {
9990 b"extLst" => {
9991 f_ext_lst =
9992 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
9993 #[cfg(feature = "extra-children")]
9994 {
9995 child_idx += 1;
9996 }
9997 }
9998 #[cfg(feature = "extra-children")]
9999 _ => {
10000 let elem = RawXmlElement::from_empty(&e);
10002 extra_children.push(PositionedNode::new(
10003 child_idx,
10004 RawXmlNode::Element(elem),
10005 ));
10006 child_idx += 1;
10007 }
10008 #[cfg(not(feature = "extra-children"))]
10009 _ => {}
10010 }
10011 }
10012 Event::End(_) => break,
10013 Event::Eof => break,
10014 _ => {}
10015 }
10016 buf.clear();
10017 }
10018 }
10019
10020 Ok(Self {
10021 bw: f_bw,
10022 show_captions: f_show_captions,
10023 layout: f_layout,
10024 frame: f_frame,
10025 ext_lst: f_ext_lst,
10026 #[cfg(feature = "extra-attrs")]
10027 extra_attrs,
10028 #[cfg(feature = "extra-children")]
10029 extra_children,
10030 })
10031 }
10032}
10033
10034impl FromXml for CTSlideSize {
10035 fn from_xml<R: BufRead>(
10036 reader: &mut Reader<R>,
10037 start_tag: &BytesStart,
10038 is_empty: bool,
10039 ) -> Result<Self, ParseError> {
10040 let mut f_cx: Option<STSlideSizeCoordinate> = None;
10041 let mut f_cy: Option<STSlideSizeCoordinate> = None;
10042 let mut f_type = None;
10043 #[cfg(feature = "extra-attrs")]
10044 let mut extra_attrs = std::collections::HashMap::new();
10045
10046 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
10048 let val = String::from_utf8_lossy(&attr.value);
10049 match attr.key.local_name().as_ref() {
10050 b"cx" => {
10051 f_cx = val.parse().ok();
10052 }
10053 b"cy" => {
10054 f_cy = val.parse().ok();
10055 }
10056 b"type" => {
10057 f_type = val.parse().ok();
10058 }
10059 #[cfg(feature = "extra-attrs")]
10060 unknown => {
10061 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
10062 extra_attrs.insert(key, val.into_owned());
10063 }
10064 #[cfg(not(feature = "extra-attrs"))]
10065 _ => {}
10066 }
10067 }
10068
10069 if !is_empty {
10070 let mut buf = Vec::new();
10071 loop {
10072 match reader.read_event_into(&mut buf)? {
10073 Event::End(_) => break,
10074 Event::Eof => break,
10075 _ => {}
10076 }
10077 buf.clear();
10078 }
10079 }
10080
10081 Ok(Self {
10082 cx: f_cx.ok_or_else(|| ParseError::MissingAttribute("cx".to_string()))?,
10083 cy: f_cy.ok_or_else(|| ParseError::MissingAttribute("cy".to_string()))?,
10084 r#type: f_type,
10085 #[cfg(feature = "extra-attrs")]
10086 extra_attrs,
10087 })
10088 }
10089}
10090
10091impl FromXml for CTKinsoku {
10092 fn from_xml<R: BufRead>(
10093 reader: &mut Reader<R>,
10094 start_tag: &BytesStart,
10095 is_empty: bool,
10096 ) -> Result<Self, ParseError> {
10097 let mut f_lang = None;
10098 let mut f_inval_st_chars: Option<String> = None;
10099 let mut f_inval_end_chars: Option<String> = None;
10100 #[cfg(feature = "extra-attrs")]
10101 let mut extra_attrs = std::collections::HashMap::new();
10102
10103 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
10105 let val = String::from_utf8_lossy(&attr.value);
10106 match attr.key.local_name().as_ref() {
10107 b"lang" => {
10108 f_lang = Some(val.into_owned());
10109 }
10110 b"invalStChars" => {
10111 f_inval_st_chars = Some(val.into_owned());
10112 }
10113 b"invalEndChars" => {
10114 f_inval_end_chars = Some(val.into_owned());
10115 }
10116 #[cfg(feature = "extra-attrs")]
10117 unknown => {
10118 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
10119 extra_attrs.insert(key, val.into_owned());
10120 }
10121 #[cfg(not(feature = "extra-attrs"))]
10122 _ => {}
10123 }
10124 }
10125
10126 if !is_empty {
10127 let mut buf = Vec::new();
10128 loop {
10129 match reader.read_event_into(&mut buf)? {
10130 Event::End(_) => break,
10131 Event::Eof => break,
10132 _ => {}
10133 }
10134 buf.clear();
10135 }
10136 }
10137
10138 Ok(Self {
10139 lang: f_lang,
10140 inval_st_chars: f_inval_st_chars
10141 .ok_or_else(|| ParseError::MissingAttribute("invalStChars".to_string()))?,
10142 inval_end_chars: f_inval_end_chars
10143 .ok_or_else(|| ParseError::MissingAttribute("invalEndChars".to_string()))?,
10144 #[cfg(feature = "extra-attrs")]
10145 extra_attrs,
10146 })
10147 }
10148}
10149
10150impl FromXml for CTModifyVerifier {
10151 fn from_xml<R: BufRead>(
10152 reader: &mut Reader<R>,
10153 start_tag: &BytesStart,
10154 is_empty: bool,
10155 ) -> Result<Self, ParseError> {
10156 let mut f_algorithm_name = None;
10157 let mut f_hash_value = None;
10158 let mut f_salt_value = None;
10159 let mut f_spin_value = None;
10160 let mut f_crypt_provider_type = None;
10161 let mut f_crypt_algorithm_class = None;
10162 let mut f_crypt_algorithm_type = None;
10163 let mut f_crypt_algorithm_sid = None;
10164 let mut f_spin_count = None;
10165 let mut f_salt_data = None;
10166 let mut f_hash_data = None;
10167 let mut f_crypt_provider = None;
10168 let mut f_alg_id_ext = None;
10169 let mut f_alg_id_ext_source = None;
10170 let mut f_crypt_provider_type_ext = None;
10171 let mut f_crypt_provider_type_ext_source = None;
10172 #[cfg(feature = "extra-attrs")]
10173 let mut extra_attrs = std::collections::HashMap::new();
10174
10175 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
10177 let val = String::from_utf8_lossy(&attr.value);
10178 match attr.key.local_name().as_ref() {
10179 b"algorithmName" => {
10180 f_algorithm_name = Some(val.into_owned());
10181 }
10182 b"hashValue" => {
10183 f_hash_value = decode_base64(&val);
10184 }
10185 b"saltValue" => {
10186 f_salt_value = decode_base64(&val);
10187 }
10188 b"spinValue" => {
10189 f_spin_value = val.parse().ok();
10190 }
10191 b"cryptProviderType" => {
10192 f_crypt_provider_type = val.parse().ok();
10193 }
10194 b"cryptAlgorithmClass" => {
10195 f_crypt_algorithm_class = val.parse().ok();
10196 }
10197 b"cryptAlgorithmType" => {
10198 f_crypt_algorithm_type = val.parse().ok();
10199 }
10200 b"cryptAlgorithmSid" => {
10201 f_crypt_algorithm_sid = val.parse().ok();
10202 }
10203 b"spinCount" => {
10204 f_spin_count = val.parse().ok();
10205 }
10206 b"saltData" => {
10207 f_salt_data = decode_base64(&val);
10208 }
10209 b"hashData" => {
10210 f_hash_data = decode_base64(&val);
10211 }
10212 b"cryptProvider" => {
10213 f_crypt_provider = Some(val.into_owned());
10214 }
10215 b"algIdExt" => {
10216 f_alg_id_ext = val.parse().ok();
10217 }
10218 b"algIdExtSource" => {
10219 f_alg_id_ext_source = Some(val.into_owned());
10220 }
10221 b"cryptProviderTypeExt" => {
10222 f_crypt_provider_type_ext = val.parse().ok();
10223 }
10224 b"cryptProviderTypeExtSource" => {
10225 f_crypt_provider_type_ext_source = Some(val.into_owned());
10226 }
10227 #[cfg(feature = "extra-attrs")]
10228 unknown => {
10229 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
10230 extra_attrs.insert(key, val.into_owned());
10231 }
10232 #[cfg(not(feature = "extra-attrs"))]
10233 _ => {}
10234 }
10235 }
10236
10237 if !is_empty {
10238 let mut buf = Vec::new();
10239 loop {
10240 match reader.read_event_into(&mut buf)? {
10241 Event::End(_) => break,
10242 Event::Eof => break,
10243 _ => {}
10244 }
10245 buf.clear();
10246 }
10247 }
10248
10249 Ok(Self {
10250 algorithm_name: f_algorithm_name,
10251 hash_value: f_hash_value,
10252 salt_value: f_salt_value,
10253 spin_value: f_spin_value,
10254 crypt_provider_type: f_crypt_provider_type,
10255 crypt_algorithm_class: f_crypt_algorithm_class,
10256 crypt_algorithm_type: f_crypt_algorithm_type,
10257 crypt_algorithm_sid: f_crypt_algorithm_sid,
10258 spin_count: f_spin_count,
10259 salt_data: f_salt_data,
10260 hash_data: f_hash_data,
10261 crypt_provider: f_crypt_provider,
10262 alg_id_ext: f_alg_id_ext,
10263 alg_id_ext_source: f_alg_id_ext_source,
10264 crypt_provider_type_ext: f_crypt_provider_type_ext,
10265 crypt_provider_type_ext_source: f_crypt_provider_type_ext_source,
10266 #[cfg(feature = "extra-attrs")]
10267 extra_attrs,
10268 })
10269 }
10270}
10271
10272impl FromXml for Presentation {
10273 fn from_xml<R: BufRead>(
10274 reader: &mut Reader<R>,
10275 start_tag: &BytesStart,
10276 is_empty: bool,
10277 ) -> Result<Self, ParseError> {
10278 #[cfg(feature = "pml-styling")]
10279 let mut f_server_zoom = None;
10280 let mut f_first_slide_num = None;
10281 #[cfg(feature = "pml-styling")]
10282 let mut f_show_special_pls_on_title_sld = None;
10283 #[cfg(feature = "pml-styling")]
10284 let mut f_rtl = None;
10285 let mut f_remove_personal_info_on_save = None;
10286 let mut f_compat_mode = None;
10287 #[cfg(feature = "pml-styling")]
10288 let mut f_strict_first_and_last_chars = None;
10289 #[cfg(feature = "pml-styling")]
10290 let mut f_embed_true_type_fonts = None;
10291 #[cfg(feature = "pml-styling")]
10292 let mut f_save_subset_fonts = None;
10293 #[cfg(feature = "pml-styling")]
10294 let mut f_auto_compress_pictures = None;
10295 let mut f_bookmark_id_seed = None;
10296 let mut f_conformance = None;
10297 let mut f_sld_master_id_lst = None;
10298 #[cfg(feature = "pml-notes")]
10299 let mut f_notes_master_id_lst = None;
10300 #[cfg(feature = "pml-masters")]
10301 let mut f_handout_master_id_lst = None;
10302 let mut f_sld_id_lst = None;
10303 let mut f_sld_sz = None;
10304 #[cfg(feature = "pml-notes")]
10305 let mut f_notes_sz: Option<Box<ooxml_dml::types::PositiveSize2D>> = None;
10306 #[cfg(feature = "pml-external")]
10307 let mut f_smart_tags = None;
10308 #[cfg(feature = "pml-styling")]
10309 let mut f_embedded_font_lst = None;
10310 let mut f_cust_show_lst = None;
10311 #[cfg(feature = "pml-media")]
10312 let mut f_photo_album = None;
10313 #[cfg(feature = "pml-external")]
10314 let mut f_cust_data_lst = None;
10315 #[cfg(feature = "pml-styling")]
10316 let mut f_kinsoku = None;
10317 #[cfg(feature = "pml-styling")]
10318 let mut f_default_text_style = None;
10319 let mut f_modify_verifier = None;
10320 #[cfg(feature = "pml-extensions")]
10321 let mut f_ext_lst = None;
10322 #[cfg(feature = "extra-attrs")]
10323 let mut extra_attrs = std::collections::HashMap::new();
10324 #[cfg(feature = "extra-children")]
10325 let mut extra_children = Vec::new();
10326 #[cfg(feature = "extra-children")]
10327 let mut child_idx: usize = 0;
10328
10329 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
10331 let val = String::from_utf8_lossy(&attr.value);
10332 match attr.key.local_name().as_ref() {
10333 #[cfg(feature = "pml-styling")]
10334 b"serverZoom" => {
10335 f_server_zoom = val.parse().ok();
10336 }
10337 b"firstSlideNum" => {
10338 f_first_slide_num = val.parse().ok();
10339 }
10340 #[cfg(feature = "pml-styling")]
10341 b"showSpecialPlsOnTitleSld" => {
10342 f_show_special_pls_on_title_sld = Some(val == "true" || val == "1");
10343 }
10344 #[cfg(feature = "pml-styling")]
10345 b"rtl" => {
10346 f_rtl = Some(val == "true" || val == "1");
10347 }
10348 b"removePersonalInfoOnSave" => {
10349 f_remove_personal_info_on_save = Some(val == "true" || val == "1");
10350 }
10351 b"compatMode" => {
10352 f_compat_mode = Some(val == "true" || val == "1");
10353 }
10354 #[cfg(feature = "pml-styling")]
10355 b"strictFirstAndLastChars" => {
10356 f_strict_first_and_last_chars = Some(val == "true" || val == "1");
10357 }
10358 #[cfg(feature = "pml-styling")]
10359 b"embedTrueTypeFonts" => {
10360 f_embed_true_type_fonts = Some(val == "true" || val == "1");
10361 }
10362 #[cfg(feature = "pml-styling")]
10363 b"saveSubsetFonts" => {
10364 f_save_subset_fonts = Some(val == "true" || val == "1");
10365 }
10366 #[cfg(feature = "pml-styling")]
10367 b"autoCompressPictures" => {
10368 f_auto_compress_pictures = Some(val == "true" || val == "1");
10369 }
10370 b"bookmarkIdSeed" => {
10371 f_bookmark_id_seed = val.parse().ok();
10372 }
10373 b"conformance" => {
10374 f_conformance = val.parse().ok();
10375 }
10376 #[cfg(feature = "extra-attrs")]
10377 unknown => {
10378 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
10379 extra_attrs.insert(key, val.into_owned());
10380 }
10381 #[cfg(not(feature = "extra-attrs"))]
10382 _ => {}
10383 }
10384 }
10385
10386 if !is_empty {
10388 let mut buf = Vec::new();
10389 loop {
10390 match reader.read_event_into(&mut buf)? {
10391 Event::Start(e) => {
10392 match e.local_name().as_ref() {
10393 b"sldMasterIdLst" => {
10394 f_sld_master_id_lst = Some(Box::new(
10395 CTSlideMasterIdList::from_xml(reader, &e, false)?,
10396 ));
10397 #[cfg(feature = "extra-children")]
10398 {
10399 child_idx += 1;
10400 }
10401 }
10402 #[cfg(feature = "pml-notes")]
10403 b"notesMasterIdLst" => {
10404 f_notes_master_id_lst = Some(Box::new(
10405 CTNotesMasterIdList::from_xml(reader, &e, false)?,
10406 ));
10407 #[cfg(feature = "extra-children")]
10408 {
10409 child_idx += 1;
10410 }
10411 }
10412 #[cfg(feature = "pml-masters")]
10413 b"handoutMasterIdLst" => {
10414 f_handout_master_id_lst = Some(Box::new(
10415 CTHandoutMasterIdList::from_xml(reader, &e, false)?,
10416 ));
10417 #[cfg(feature = "extra-children")]
10418 {
10419 child_idx += 1;
10420 }
10421 }
10422 b"sldIdLst" => {
10423 f_sld_id_lst =
10424 Some(Box::new(SlideIdList::from_xml(reader, &e, false)?));
10425 #[cfg(feature = "extra-children")]
10426 {
10427 child_idx += 1;
10428 }
10429 }
10430 b"sldSz" => {
10431 f_sld_sz =
10432 Some(Box::new(CTSlideSize::from_xml(reader, &e, false)?));
10433 #[cfg(feature = "extra-children")]
10434 {
10435 child_idx += 1;
10436 }
10437 }
10438 #[cfg(feature = "pml-notes")]
10439 b"notesSz" => {
10440 f_notes_sz = Some(Box::new(
10441 ooxml_dml::types::PositiveSize2D::from_xml(reader, &e, false)?,
10442 ));
10443 #[cfg(feature = "extra-children")]
10444 {
10445 child_idx += 1;
10446 }
10447 }
10448 #[cfg(feature = "pml-external")]
10449 b"smartTags" => {
10450 f_smart_tags =
10451 Some(Box::new(CTSmartTags::from_xml(reader, &e, false)?));
10452 #[cfg(feature = "extra-children")]
10453 {
10454 child_idx += 1;
10455 }
10456 }
10457 #[cfg(feature = "pml-styling")]
10458 b"embeddedFontLst" => {
10459 f_embedded_font_lst = Some(Box::new(CTEmbeddedFontList::from_xml(
10460 reader, &e, false,
10461 )?));
10462 #[cfg(feature = "extra-children")]
10463 {
10464 child_idx += 1;
10465 }
10466 }
10467 b"custShowLst" => {
10468 f_cust_show_lst =
10469 Some(Box::new(CTCustomShowList::from_xml(reader, &e, false)?));
10470 #[cfg(feature = "extra-children")]
10471 {
10472 child_idx += 1;
10473 }
10474 }
10475 #[cfg(feature = "pml-media")]
10476 b"photoAlbum" => {
10477 f_photo_album =
10478 Some(Box::new(CTPhotoAlbum::from_xml(reader, &e, false)?));
10479 #[cfg(feature = "extra-children")]
10480 {
10481 child_idx += 1;
10482 }
10483 }
10484 #[cfg(feature = "pml-external")]
10485 b"custDataLst" => {
10486 f_cust_data_lst = Some(Box::new(CTCustomerDataList::from_xml(
10487 reader, &e, false,
10488 )?));
10489 #[cfg(feature = "extra-children")]
10490 {
10491 child_idx += 1;
10492 }
10493 }
10494 #[cfg(feature = "pml-styling")]
10495 b"kinsoku" => {
10496 f_kinsoku = Some(Box::new(CTKinsoku::from_xml(reader, &e, false)?));
10497 #[cfg(feature = "extra-children")]
10498 {
10499 child_idx += 1;
10500 }
10501 }
10502 #[cfg(feature = "pml-styling")]
10503 b"defaultTextStyle" => {
10504 f_default_text_style = Some(Box::new(
10505 ooxml_dml::types::CTTextListStyle::from_xml(reader, &e, false)?,
10506 ));
10507 #[cfg(feature = "extra-children")]
10508 {
10509 child_idx += 1;
10510 }
10511 }
10512 b"modifyVerifier" => {
10513 f_modify_verifier =
10514 Some(Box::new(CTModifyVerifier::from_xml(reader, &e, false)?));
10515 #[cfg(feature = "extra-children")]
10516 {
10517 child_idx += 1;
10518 }
10519 }
10520 #[cfg(feature = "pml-extensions")]
10521 b"extLst" => {
10522 f_ext_lst =
10523 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
10524 #[cfg(feature = "extra-children")]
10525 {
10526 child_idx += 1;
10527 }
10528 }
10529 #[cfg(feature = "extra-children")]
10530 _ => {
10531 let elem = RawXmlElement::from_reader(reader, &e)?;
10533 extra_children.push(PositionedNode::new(
10534 child_idx,
10535 RawXmlNode::Element(elem),
10536 ));
10537 child_idx += 1;
10538 }
10539 #[cfg(not(feature = "extra-children"))]
10540 _ => {
10541 skip_element(reader)?;
10543 }
10544 }
10545 }
10546 Event::Empty(e) => {
10547 match e.local_name().as_ref() {
10548 b"sldMasterIdLst" => {
10549 f_sld_master_id_lst = Some(Box::new(
10550 CTSlideMasterIdList::from_xml(reader, &e, true)?,
10551 ));
10552 #[cfg(feature = "extra-children")]
10553 {
10554 child_idx += 1;
10555 }
10556 }
10557 #[cfg(feature = "pml-notes")]
10558 b"notesMasterIdLst" => {
10559 f_notes_master_id_lst = Some(Box::new(
10560 CTNotesMasterIdList::from_xml(reader, &e, true)?,
10561 ));
10562 #[cfg(feature = "extra-children")]
10563 {
10564 child_idx += 1;
10565 }
10566 }
10567 #[cfg(feature = "pml-masters")]
10568 b"handoutMasterIdLst" => {
10569 f_handout_master_id_lst = Some(Box::new(
10570 CTHandoutMasterIdList::from_xml(reader, &e, true)?,
10571 ));
10572 #[cfg(feature = "extra-children")]
10573 {
10574 child_idx += 1;
10575 }
10576 }
10577 b"sldIdLst" => {
10578 f_sld_id_lst =
10579 Some(Box::new(SlideIdList::from_xml(reader, &e, true)?));
10580 #[cfg(feature = "extra-children")]
10581 {
10582 child_idx += 1;
10583 }
10584 }
10585 b"sldSz" => {
10586 f_sld_sz = Some(Box::new(CTSlideSize::from_xml(reader, &e, true)?));
10587 #[cfg(feature = "extra-children")]
10588 {
10589 child_idx += 1;
10590 }
10591 }
10592 #[cfg(feature = "pml-notes")]
10593 b"notesSz" => {
10594 f_notes_sz = Some(Box::new(
10595 ooxml_dml::types::PositiveSize2D::from_xml(reader, &e, true)?,
10596 ));
10597 #[cfg(feature = "extra-children")]
10598 {
10599 child_idx += 1;
10600 }
10601 }
10602 #[cfg(feature = "pml-external")]
10603 b"smartTags" => {
10604 f_smart_tags =
10605 Some(Box::new(CTSmartTags::from_xml(reader, &e, true)?));
10606 #[cfg(feature = "extra-children")]
10607 {
10608 child_idx += 1;
10609 }
10610 }
10611 #[cfg(feature = "pml-styling")]
10612 b"embeddedFontLst" => {
10613 f_embedded_font_lst =
10614 Some(Box::new(CTEmbeddedFontList::from_xml(reader, &e, true)?));
10615 #[cfg(feature = "extra-children")]
10616 {
10617 child_idx += 1;
10618 }
10619 }
10620 b"custShowLst" => {
10621 f_cust_show_lst =
10622 Some(Box::new(CTCustomShowList::from_xml(reader, &e, true)?));
10623 #[cfg(feature = "extra-children")]
10624 {
10625 child_idx += 1;
10626 }
10627 }
10628 #[cfg(feature = "pml-media")]
10629 b"photoAlbum" => {
10630 f_photo_album =
10631 Some(Box::new(CTPhotoAlbum::from_xml(reader, &e, true)?));
10632 #[cfg(feature = "extra-children")]
10633 {
10634 child_idx += 1;
10635 }
10636 }
10637 #[cfg(feature = "pml-external")]
10638 b"custDataLst" => {
10639 f_cust_data_lst =
10640 Some(Box::new(CTCustomerDataList::from_xml(reader, &e, true)?));
10641 #[cfg(feature = "extra-children")]
10642 {
10643 child_idx += 1;
10644 }
10645 }
10646 #[cfg(feature = "pml-styling")]
10647 b"kinsoku" => {
10648 f_kinsoku = Some(Box::new(CTKinsoku::from_xml(reader, &e, true)?));
10649 #[cfg(feature = "extra-children")]
10650 {
10651 child_idx += 1;
10652 }
10653 }
10654 #[cfg(feature = "pml-styling")]
10655 b"defaultTextStyle" => {
10656 f_default_text_style = Some(Box::new(
10657 ooxml_dml::types::CTTextListStyle::from_xml(reader, &e, true)?,
10658 ));
10659 #[cfg(feature = "extra-children")]
10660 {
10661 child_idx += 1;
10662 }
10663 }
10664 b"modifyVerifier" => {
10665 f_modify_verifier =
10666 Some(Box::new(CTModifyVerifier::from_xml(reader, &e, true)?));
10667 #[cfg(feature = "extra-children")]
10668 {
10669 child_idx += 1;
10670 }
10671 }
10672 #[cfg(feature = "pml-extensions")]
10673 b"extLst" => {
10674 f_ext_lst =
10675 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
10676 #[cfg(feature = "extra-children")]
10677 {
10678 child_idx += 1;
10679 }
10680 }
10681 #[cfg(feature = "extra-children")]
10682 _ => {
10683 let elem = RawXmlElement::from_empty(&e);
10685 extra_children.push(PositionedNode::new(
10686 child_idx,
10687 RawXmlNode::Element(elem),
10688 ));
10689 child_idx += 1;
10690 }
10691 #[cfg(not(feature = "extra-children"))]
10692 _ => {}
10693 }
10694 }
10695 Event::End(_) => break,
10696 Event::Eof => break,
10697 _ => {}
10698 }
10699 buf.clear();
10700 }
10701 }
10702
10703 Ok(Self {
10704 #[cfg(feature = "pml-styling")]
10705 server_zoom: f_server_zoom,
10706 first_slide_num: f_first_slide_num,
10707 #[cfg(feature = "pml-styling")]
10708 show_special_pls_on_title_sld: f_show_special_pls_on_title_sld,
10709 #[cfg(feature = "pml-styling")]
10710 rtl: f_rtl,
10711 remove_personal_info_on_save: f_remove_personal_info_on_save,
10712 compat_mode: f_compat_mode,
10713 #[cfg(feature = "pml-styling")]
10714 strict_first_and_last_chars: f_strict_first_and_last_chars,
10715 #[cfg(feature = "pml-styling")]
10716 embed_true_type_fonts: f_embed_true_type_fonts,
10717 #[cfg(feature = "pml-styling")]
10718 save_subset_fonts: f_save_subset_fonts,
10719 #[cfg(feature = "pml-styling")]
10720 auto_compress_pictures: f_auto_compress_pictures,
10721 bookmark_id_seed: f_bookmark_id_seed,
10722 conformance: f_conformance,
10723 sld_master_id_lst: f_sld_master_id_lst,
10724 #[cfg(feature = "pml-notes")]
10725 notes_master_id_lst: f_notes_master_id_lst,
10726 #[cfg(feature = "pml-masters")]
10727 handout_master_id_lst: f_handout_master_id_lst,
10728 sld_id_lst: f_sld_id_lst,
10729 sld_sz: f_sld_sz,
10730 #[cfg(feature = "pml-notes")]
10731 notes_sz: f_notes_sz
10732 .ok_or_else(|| ParseError::MissingAttribute("notesSz".to_string()))?,
10733 #[cfg(feature = "pml-external")]
10734 smart_tags: f_smart_tags,
10735 #[cfg(feature = "pml-styling")]
10736 embedded_font_lst: f_embedded_font_lst,
10737 cust_show_lst: f_cust_show_lst,
10738 #[cfg(feature = "pml-media")]
10739 photo_album: f_photo_album,
10740 #[cfg(feature = "pml-external")]
10741 cust_data_lst: f_cust_data_lst,
10742 #[cfg(feature = "pml-styling")]
10743 kinsoku: f_kinsoku,
10744 #[cfg(feature = "pml-styling")]
10745 default_text_style: f_default_text_style,
10746 modify_verifier: f_modify_verifier,
10747 #[cfg(feature = "pml-extensions")]
10748 ext_lst: f_ext_lst,
10749 #[cfg(feature = "extra-attrs")]
10750 extra_attrs,
10751 #[cfg(feature = "extra-children")]
10752 extra_children,
10753 })
10754 }
10755}
10756
10757impl FromXml for CTHtmlPublishProperties {
10758 fn from_xml<R: BufRead>(
10759 reader: &mut Reader<R>,
10760 start_tag: &BytesStart,
10761 is_empty: bool,
10762 ) -> Result<Self, ParseError> {
10763 let mut f_show_speaker_notes = None;
10764 let mut f_target = None;
10765 let mut f_title = None;
10766 let mut f_slide_list_choice: Option<Box<EGSlideListChoice>> = None;
10767 let mut f_ext_lst = None;
10768 #[cfg(feature = "extra-attrs")]
10769 let mut extra_attrs = std::collections::HashMap::new();
10770 #[cfg(feature = "extra-children")]
10771 let mut extra_children = Vec::new();
10772 #[cfg(feature = "extra-children")]
10773 let mut child_idx: usize = 0;
10774
10775 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
10777 let val = String::from_utf8_lossy(&attr.value);
10778 match attr.key.local_name().as_ref() {
10779 b"showSpeakerNotes" => {
10780 f_show_speaker_notes = Some(val == "true" || val == "1");
10781 }
10782 b"target" => {
10783 f_target = Some(val.into_owned());
10784 }
10785 b"title" => {
10786 f_title = Some(val.into_owned());
10787 }
10788 #[cfg(feature = "extra-attrs")]
10789 unknown => {
10790 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
10791 extra_attrs.insert(key, val.into_owned());
10792 }
10793 #[cfg(not(feature = "extra-attrs"))]
10794 _ => {}
10795 }
10796 }
10797
10798 if !is_empty {
10800 let mut buf = Vec::new();
10801 loop {
10802 match reader.read_event_into(&mut buf)? {
10803 Event::Start(e) => {
10804 match e.local_name().as_ref() {
10805 b"sldAll" | b"sldRg" | b"custShow" => {
10806 f_slide_list_choice =
10807 Some(Box::new(EGSlideListChoice::from_xml(reader, &e, false)?));
10808 #[cfg(feature = "extra-children")]
10809 {
10810 child_idx += 1;
10811 }
10812 }
10813 b"extLst" => {
10814 f_ext_lst =
10815 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
10816 #[cfg(feature = "extra-children")]
10817 {
10818 child_idx += 1;
10819 }
10820 }
10821 #[cfg(feature = "extra-children")]
10822 _ => {
10823 let elem = RawXmlElement::from_reader(reader, &e)?;
10825 extra_children.push(PositionedNode::new(
10826 child_idx,
10827 RawXmlNode::Element(elem),
10828 ));
10829 child_idx += 1;
10830 }
10831 #[cfg(not(feature = "extra-children"))]
10832 _ => {
10833 skip_element(reader)?;
10835 }
10836 }
10837 }
10838 Event::Empty(e) => {
10839 match e.local_name().as_ref() {
10840 b"sldAll" | b"sldRg" | b"custShow" => {
10841 f_slide_list_choice =
10842 Some(Box::new(EGSlideListChoice::from_xml(reader, &e, true)?));
10843 #[cfg(feature = "extra-children")]
10844 {
10845 child_idx += 1;
10846 }
10847 }
10848 b"extLst" => {
10849 f_ext_lst =
10850 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
10851 #[cfg(feature = "extra-children")]
10852 {
10853 child_idx += 1;
10854 }
10855 }
10856 #[cfg(feature = "extra-children")]
10857 _ => {
10858 let elem = RawXmlElement::from_empty(&e);
10860 extra_children.push(PositionedNode::new(
10861 child_idx,
10862 RawXmlNode::Element(elem),
10863 ));
10864 child_idx += 1;
10865 }
10866 #[cfg(not(feature = "extra-children"))]
10867 _ => {}
10868 }
10869 }
10870 Event::End(_) => break,
10871 Event::Eof => break,
10872 _ => {}
10873 }
10874 buf.clear();
10875 }
10876 }
10877
10878 Ok(Self {
10879 show_speaker_notes: f_show_speaker_notes,
10880 target: f_target,
10881 title: f_title,
10882 slide_list_choice: f_slide_list_choice,
10883 ext_lst: f_ext_lst,
10884 #[cfg(feature = "extra-attrs")]
10885 extra_attrs,
10886 #[cfg(feature = "extra-children")]
10887 extra_children,
10888 })
10889 }
10890}
10891
10892impl FromXml for CTWebProperties {
10893 fn from_xml<R: BufRead>(
10894 reader: &mut Reader<R>,
10895 start_tag: &BytesStart,
10896 is_empty: bool,
10897 ) -> Result<Self, ParseError> {
10898 let mut f_show_animation = None;
10899 let mut f_resize_graphics = None;
10900 let mut f_allow_png = None;
10901 let mut f_rely_on_vml = None;
10902 let mut f_organize_in_folders = None;
10903 let mut f_use_long_filenames = None;
10904 let mut f_img_sz = None;
10905 let mut f_encoding = None;
10906 let mut f_clr = None;
10907 let mut f_ext_lst = None;
10908 #[cfg(feature = "extra-attrs")]
10909 let mut extra_attrs = std::collections::HashMap::new();
10910 #[cfg(feature = "extra-children")]
10911 let mut extra_children = Vec::new();
10912 #[cfg(feature = "extra-children")]
10913 let mut child_idx: usize = 0;
10914
10915 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
10917 let val = String::from_utf8_lossy(&attr.value);
10918 match attr.key.local_name().as_ref() {
10919 b"showAnimation" => {
10920 f_show_animation = Some(val == "true" || val == "1");
10921 }
10922 b"resizeGraphics" => {
10923 f_resize_graphics = Some(val == "true" || val == "1");
10924 }
10925 b"allowPng" => {
10926 f_allow_png = Some(val == "true" || val == "1");
10927 }
10928 b"relyOnVml" => {
10929 f_rely_on_vml = Some(val == "true" || val == "1");
10930 }
10931 b"organizeInFolders" => {
10932 f_organize_in_folders = Some(val == "true" || val == "1");
10933 }
10934 b"useLongFilenames" => {
10935 f_use_long_filenames = Some(val == "true" || val == "1");
10936 }
10937 b"imgSz" => {
10938 f_img_sz = val.parse().ok();
10939 }
10940 b"encoding" => {
10941 f_encoding = Some(val.into_owned());
10942 }
10943 b"clr" => {
10944 f_clr = val.parse().ok();
10945 }
10946 #[cfg(feature = "extra-attrs")]
10947 unknown => {
10948 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
10949 extra_attrs.insert(key, val.into_owned());
10950 }
10951 #[cfg(not(feature = "extra-attrs"))]
10952 _ => {}
10953 }
10954 }
10955
10956 if !is_empty {
10958 let mut buf = Vec::new();
10959 loop {
10960 match reader.read_event_into(&mut buf)? {
10961 Event::Start(e) => {
10962 match e.local_name().as_ref() {
10963 b"extLst" => {
10964 f_ext_lst =
10965 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
10966 #[cfg(feature = "extra-children")]
10967 {
10968 child_idx += 1;
10969 }
10970 }
10971 #[cfg(feature = "extra-children")]
10972 _ => {
10973 let elem = RawXmlElement::from_reader(reader, &e)?;
10975 extra_children.push(PositionedNode::new(
10976 child_idx,
10977 RawXmlNode::Element(elem),
10978 ));
10979 child_idx += 1;
10980 }
10981 #[cfg(not(feature = "extra-children"))]
10982 _ => {
10983 skip_element(reader)?;
10985 }
10986 }
10987 }
10988 Event::Empty(e) => {
10989 match e.local_name().as_ref() {
10990 b"extLst" => {
10991 f_ext_lst =
10992 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
10993 #[cfg(feature = "extra-children")]
10994 {
10995 child_idx += 1;
10996 }
10997 }
10998 #[cfg(feature = "extra-children")]
10999 _ => {
11000 let elem = RawXmlElement::from_empty(&e);
11002 extra_children.push(PositionedNode::new(
11003 child_idx,
11004 RawXmlNode::Element(elem),
11005 ));
11006 child_idx += 1;
11007 }
11008 #[cfg(not(feature = "extra-children"))]
11009 _ => {}
11010 }
11011 }
11012 Event::End(_) => break,
11013 Event::Eof => break,
11014 _ => {}
11015 }
11016 buf.clear();
11017 }
11018 }
11019
11020 Ok(Self {
11021 show_animation: f_show_animation,
11022 resize_graphics: f_resize_graphics,
11023 allow_png: f_allow_png,
11024 rely_on_vml: f_rely_on_vml,
11025 organize_in_folders: f_organize_in_folders,
11026 use_long_filenames: f_use_long_filenames,
11027 img_sz: f_img_sz,
11028 encoding: f_encoding,
11029 clr: f_clr,
11030 ext_lst: f_ext_lst,
11031 #[cfg(feature = "extra-attrs")]
11032 extra_attrs,
11033 #[cfg(feature = "extra-children")]
11034 extra_children,
11035 })
11036 }
11037}
11038
11039impl FromXml for CTPrintProperties {
11040 fn from_xml<R: BufRead>(
11041 reader: &mut Reader<R>,
11042 start_tag: &BytesStart,
11043 is_empty: bool,
11044 ) -> Result<Self, ParseError> {
11045 let mut f_prn_what = None;
11046 let mut f_clr_mode = None;
11047 let mut f_hidden_slides = None;
11048 let mut f_scale_to_fit_paper = None;
11049 let mut f_frame_slides = None;
11050 let mut f_ext_lst = None;
11051 #[cfg(feature = "extra-attrs")]
11052 let mut extra_attrs = std::collections::HashMap::new();
11053 #[cfg(feature = "extra-children")]
11054 let mut extra_children = Vec::new();
11055 #[cfg(feature = "extra-children")]
11056 let mut child_idx: usize = 0;
11057
11058 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
11060 let val = String::from_utf8_lossy(&attr.value);
11061 match attr.key.local_name().as_ref() {
11062 b"prnWhat" => {
11063 f_prn_what = val.parse().ok();
11064 }
11065 b"clrMode" => {
11066 f_clr_mode = val.parse().ok();
11067 }
11068 b"hiddenSlides" => {
11069 f_hidden_slides = Some(val == "true" || val == "1");
11070 }
11071 b"scaleToFitPaper" => {
11072 f_scale_to_fit_paper = Some(val == "true" || val == "1");
11073 }
11074 b"frameSlides" => {
11075 f_frame_slides = Some(val == "true" || val == "1");
11076 }
11077 #[cfg(feature = "extra-attrs")]
11078 unknown => {
11079 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
11080 extra_attrs.insert(key, val.into_owned());
11081 }
11082 #[cfg(not(feature = "extra-attrs"))]
11083 _ => {}
11084 }
11085 }
11086
11087 if !is_empty {
11089 let mut buf = Vec::new();
11090 loop {
11091 match reader.read_event_into(&mut buf)? {
11092 Event::Start(e) => {
11093 match e.local_name().as_ref() {
11094 b"extLst" => {
11095 f_ext_lst =
11096 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
11097 #[cfg(feature = "extra-children")]
11098 {
11099 child_idx += 1;
11100 }
11101 }
11102 #[cfg(feature = "extra-children")]
11103 _ => {
11104 let elem = RawXmlElement::from_reader(reader, &e)?;
11106 extra_children.push(PositionedNode::new(
11107 child_idx,
11108 RawXmlNode::Element(elem),
11109 ));
11110 child_idx += 1;
11111 }
11112 #[cfg(not(feature = "extra-children"))]
11113 _ => {
11114 skip_element(reader)?;
11116 }
11117 }
11118 }
11119 Event::Empty(e) => {
11120 match e.local_name().as_ref() {
11121 b"extLst" => {
11122 f_ext_lst =
11123 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
11124 #[cfg(feature = "extra-children")]
11125 {
11126 child_idx += 1;
11127 }
11128 }
11129 #[cfg(feature = "extra-children")]
11130 _ => {
11131 let elem = RawXmlElement::from_empty(&e);
11133 extra_children.push(PositionedNode::new(
11134 child_idx,
11135 RawXmlNode::Element(elem),
11136 ));
11137 child_idx += 1;
11138 }
11139 #[cfg(not(feature = "extra-children"))]
11140 _ => {}
11141 }
11142 }
11143 Event::End(_) => break,
11144 Event::Eof => break,
11145 _ => {}
11146 }
11147 buf.clear();
11148 }
11149 }
11150
11151 Ok(Self {
11152 prn_what: f_prn_what,
11153 clr_mode: f_clr_mode,
11154 hidden_slides: f_hidden_slides,
11155 scale_to_fit_paper: f_scale_to_fit_paper,
11156 frame_slides: f_frame_slides,
11157 ext_lst: f_ext_lst,
11158 #[cfg(feature = "extra-attrs")]
11159 extra_attrs,
11160 #[cfg(feature = "extra-children")]
11161 extra_children,
11162 })
11163 }
11164}
11165
11166impl FromXml for CTShowInfoBrowse {
11167 fn from_xml<R: BufRead>(
11168 reader: &mut Reader<R>,
11169 start_tag: &BytesStart,
11170 is_empty: bool,
11171 ) -> Result<Self, ParseError> {
11172 let mut f_show_scrollbar = None;
11173 #[cfg(feature = "extra-attrs")]
11174 let mut extra_attrs = std::collections::HashMap::new();
11175
11176 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
11178 let val = String::from_utf8_lossy(&attr.value);
11179 match attr.key.local_name().as_ref() {
11180 b"showScrollbar" => {
11181 f_show_scrollbar = Some(val == "true" || val == "1");
11182 }
11183 #[cfg(feature = "extra-attrs")]
11184 unknown => {
11185 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
11186 extra_attrs.insert(key, val.into_owned());
11187 }
11188 #[cfg(not(feature = "extra-attrs"))]
11189 _ => {}
11190 }
11191 }
11192
11193 if !is_empty {
11194 let mut buf = Vec::new();
11195 loop {
11196 match reader.read_event_into(&mut buf)? {
11197 Event::End(_) => break,
11198 Event::Eof => break,
11199 _ => {}
11200 }
11201 buf.clear();
11202 }
11203 }
11204
11205 Ok(Self {
11206 show_scrollbar: f_show_scrollbar,
11207 #[cfg(feature = "extra-attrs")]
11208 extra_attrs,
11209 })
11210 }
11211}
11212
11213impl FromXml for CTShowInfoKiosk {
11214 fn from_xml<R: BufRead>(
11215 reader: &mut Reader<R>,
11216 start_tag: &BytesStart,
11217 is_empty: bool,
11218 ) -> Result<Self, ParseError> {
11219 let mut f_restart = None;
11220 #[cfg(feature = "extra-attrs")]
11221 let mut extra_attrs = std::collections::HashMap::new();
11222
11223 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
11225 let val = String::from_utf8_lossy(&attr.value);
11226 match attr.key.local_name().as_ref() {
11227 b"restart" => {
11228 f_restart = val.parse().ok();
11229 }
11230 #[cfg(feature = "extra-attrs")]
11231 unknown => {
11232 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
11233 extra_attrs.insert(key, val.into_owned());
11234 }
11235 #[cfg(not(feature = "extra-attrs"))]
11236 _ => {}
11237 }
11238 }
11239
11240 if !is_empty {
11241 let mut buf = Vec::new();
11242 loop {
11243 match reader.read_event_into(&mut buf)? {
11244 Event::End(_) => break,
11245 Event::Eof => break,
11246 _ => {}
11247 }
11248 buf.clear();
11249 }
11250 }
11251
11252 Ok(Self {
11253 restart: f_restart,
11254 #[cfg(feature = "extra-attrs")]
11255 extra_attrs,
11256 })
11257 }
11258}
11259
11260impl FromXml for EGShowType {
11261 fn from_xml<R: BufRead>(
11262 reader: &mut Reader<R>,
11263 start_tag: &BytesStart,
11264 is_empty: bool,
11265 ) -> Result<Self, ParseError> {
11266 let tag = start_tag.local_name();
11267 match tag.as_ref() {
11268 b"present" => {
11269 let inner = CTEmpty::from_xml(reader, start_tag, is_empty)?;
11270 Ok(Self::Present(Box::new(inner)))
11271 }
11272 b"browse" => {
11273 let inner = CTShowInfoBrowse::from_xml(reader, start_tag, is_empty)?;
11274 Ok(Self::Browse(Box::new(inner)))
11275 }
11276 b"kiosk" => {
11277 let inner = CTShowInfoKiosk::from_xml(reader, start_tag, is_empty)?;
11278 Ok(Self::Kiosk(Box::new(inner)))
11279 }
11280 _ => Err(ParseError::UnexpectedElement(
11281 String::from_utf8_lossy(start_tag.name().as_ref()).into_owned(),
11282 )),
11283 }
11284 }
11285}
11286
11287impl FromXml for CTShowProperties {
11288 fn from_xml<R: BufRead>(
11289 reader: &mut Reader<R>,
11290 start_tag: &BytesStart,
11291 is_empty: bool,
11292 ) -> Result<Self, ParseError> {
11293 let mut f_loop = None;
11294 let mut f_show_narration = None;
11295 let mut f_show_animation = None;
11296 let mut f_use_timings = None;
11297 let mut f_show_type = None;
11298 let mut f_slide_list_choice = None;
11299 let mut f_pen_clr = None;
11300 let mut f_ext_lst = None;
11301 #[cfg(feature = "extra-attrs")]
11302 let mut extra_attrs = std::collections::HashMap::new();
11303 #[cfg(feature = "extra-children")]
11304 let mut extra_children = Vec::new();
11305 #[cfg(feature = "extra-children")]
11306 let mut child_idx: usize = 0;
11307
11308 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
11310 let val = String::from_utf8_lossy(&attr.value);
11311 match attr.key.local_name().as_ref() {
11312 b"loop" => {
11313 f_loop = Some(val == "true" || val == "1");
11314 }
11315 b"showNarration" => {
11316 f_show_narration = Some(val == "true" || val == "1");
11317 }
11318 b"showAnimation" => {
11319 f_show_animation = Some(val == "true" || val == "1");
11320 }
11321 b"useTimings" => {
11322 f_use_timings = Some(val == "true" || val == "1");
11323 }
11324 #[cfg(feature = "extra-attrs")]
11325 unknown => {
11326 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
11327 extra_attrs.insert(key, val.into_owned());
11328 }
11329 #[cfg(not(feature = "extra-attrs"))]
11330 _ => {}
11331 }
11332 }
11333
11334 if !is_empty {
11336 let mut buf = Vec::new();
11337 loop {
11338 match reader.read_event_into(&mut buf)? {
11339 Event::Start(e) => {
11340 match e.local_name().as_ref() {
11341 b"present" | b"browse" | b"kiosk" => {
11342 f_show_type =
11343 Some(Box::new(EGShowType::from_xml(reader, &e, false)?));
11344 #[cfg(feature = "extra-children")]
11345 {
11346 child_idx += 1;
11347 }
11348 }
11349 b"sldAll" | b"sldRg" | b"custShow" => {
11350 f_slide_list_choice =
11351 Some(Box::new(EGSlideListChoice::from_xml(reader, &e, false)?));
11352 #[cfg(feature = "extra-children")]
11353 {
11354 child_idx += 1;
11355 }
11356 }
11357 b"penClr" => {
11358 f_pen_clr = Some(Box::new(ooxml_dml::types::CTColor::from_xml(
11359 reader, &e, false,
11360 )?));
11361 #[cfg(feature = "extra-children")]
11362 {
11363 child_idx += 1;
11364 }
11365 }
11366 b"extLst" => {
11367 f_ext_lst =
11368 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
11369 #[cfg(feature = "extra-children")]
11370 {
11371 child_idx += 1;
11372 }
11373 }
11374 #[cfg(feature = "extra-children")]
11375 _ => {
11376 let elem = RawXmlElement::from_reader(reader, &e)?;
11378 extra_children.push(PositionedNode::new(
11379 child_idx,
11380 RawXmlNode::Element(elem),
11381 ));
11382 child_idx += 1;
11383 }
11384 #[cfg(not(feature = "extra-children"))]
11385 _ => {
11386 skip_element(reader)?;
11388 }
11389 }
11390 }
11391 Event::Empty(e) => {
11392 match e.local_name().as_ref() {
11393 b"present" | b"browse" | b"kiosk" => {
11394 f_show_type =
11395 Some(Box::new(EGShowType::from_xml(reader, &e, true)?));
11396 #[cfg(feature = "extra-children")]
11397 {
11398 child_idx += 1;
11399 }
11400 }
11401 b"sldAll" | b"sldRg" | b"custShow" => {
11402 f_slide_list_choice =
11403 Some(Box::new(EGSlideListChoice::from_xml(reader, &e, true)?));
11404 #[cfg(feature = "extra-children")]
11405 {
11406 child_idx += 1;
11407 }
11408 }
11409 b"penClr" => {
11410 f_pen_clr = Some(Box::new(ooxml_dml::types::CTColor::from_xml(
11411 reader, &e, true,
11412 )?));
11413 #[cfg(feature = "extra-children")]
11414 {
11415 child_idx += 1;
11416 }
11417 }
11418 b"extLst" => {
11419 f_ext_lst =
11420 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
11421 #[cfg(feature = "extra-children")]
11422 {
11423 child_idx += 1;
11424 }
11425 }
11426 #[cfg(feature = "extra-children")]
11427 _ => {
11428 let elem = RawXmlElement::from_empty(&e);
11430 extra_children.push(PositionedNode::new(
11431 child_idx,
11432 RawXmlNode::Element(elem),
11433 ));
11434 child_idx += 1;
11435 }
11436 #[cfg(not(feature = "extra-children"))]
11437 _ => {}
11438 }
11439 }
11440 Event::End(_) => break,
11441 Event::Eof => break,
11442 _ => {}
11443 }
11444 buf.clear();
11445 }
11446 }
11447
11448 Ok(Self {
11449 r#loop: f_loop,
11450 show_narration: f_show_narration,
11451 show_animation: f_show_animation,
11452 use_timings: f_use_timings,
11453 show_type: f_show_type,
11454 slide_list_choice: f_slide_list_choice,
11455 pen_clr: f_pen_clr,
11456 ext_lst: f_ext_lst,
11457 #[cfg(feature = "extra-attrs")]
11458 extra_attrs,
11459 #[cfg(feature = "extra-children")]
11460 extra_children,
11461 })
11462 }
11463}
11464
11465impl FromXml for CTPresentationProperties {
11466 fn from_xml<R: BufRead>(
11467 reader: &mut Reader<R>,
11468 start_tag: &BytesStart,
11469 is_empty: bool,
11470 ) -> Result<Self, ParseError> {
11471 #[cfg(feature = "pml-external")]
11472 let mut f_html_pub_pr = None;
11473 #[cfg(feature = "pml-external")]
11474 let mut f_web_pr = None;
11475 let mut f_prn_pr = None;
11476 let mut f_show_pr = None;
11477 #[cfg(feature = "pml-styling")]
11478 let mut f_clr_mru = None;
11479 #[cfg(feature = "pml-extensions")]
11480 let mut f_ext_lst = None;
11481 #[cfg(feature = "extra-children")]
11482 let mut extra_children = Vec::new();
11483 #[cfg(feature = "extra-children")]
11484 let mut child_idx: usize = 0;
11485
11486 if !is_empty {
11488 let mut buf = Vec::new();
11489 loop {
11490 match reader.read_event_into(&mut buf)? {
11491 Event::Start(e) => {
11492 match e.local_name().as_ref() {
11493 #[cfg(feature = "pml-external")]
11494 b"htmlPubPr" => {
11495 f_html_pub_pr = Some(Box::new(CTHtmlPublishProperties::from_xml(
11496 reader, &e, false,
11497 )?));
11498 #[cfg(feature = "extra-children")]
11499 {
11500 child_idx += 1;
11501 }
11502 }
11503 #[cfg(feature = "pml-external")]
11504 b"webPr" => {
11505 f_web_pr =
11506 Some(Box::new(CTWebProperties::from_xml(reader, &e, false)?));
11507 #[cfg(feature = "extra-children")]
11508 {
11509 child_idx += 1;
11510 }
11511 }
11512 b"prnPr" => {
11513 f_prn_pr =
11514 Some(Box::new(CTPrintProperties::from_xml(reader, &e, false)?));
11515 #[cfg(feature = "extra-children")]
11516 {
11517 child_idx += 1;
11518 }
11519 }
11520 b"showPr" => {
11521 f_show_pr =
11522 Some(Box::new(CTShowProperties::from_xml(reader, &e, false)?));
11523 #[cfg(feature = "extra-children")]
11524 {
11525 child_idx += 1;
11526 }
11527 }
11528 #[cfg(feature = "pml-styling")]
11529 b"clrMru" => {
11530 f_clr_mru = Some(Box::new(ooxml_dml::types::CTColorMRU::from_xml(
11531 reader, &e, false,
11532 )?));
11533 #[cfg(feature = "extra-children")]
11534 {
11535 child_idx += 1;
11536 }
11537 }
11538 #[cfg(feature = "pml-extensions")]
11539 b"extLst" => {
11540 f_ext_lst =
11541 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
11542 #[cfg(feature = "extra-children")]
11543 {
11544 child_idx += 1;
11545 }
11546 }
11547 #[cfg(feature = "extra-children")]
11548 _ => {
11549 let elem = RawXmlElement::from_reader(reader, &e)?;
11551 extra_children.push(PositionedNode::new(
11552 child_idx,
11553 RawXmlNode::Element(elem),
11554 ));
11555 child_idx += 1;
11556 }
11557 #[cfg(not(feature = "extra-children"))]
11558 _ => {
11559 skip_element(reader)?;
11561 }
11562 }
11563 }
11564 Event::Empty(e) => {
11565 match e.local_name().as_ref() {
11566 #[cfg(feature = "pml-external")]
11567 b"htmlPubPr" => {
11568 f_html_pub_pr = Some(Box::new(CTHtmlPublishProperties::from_xml(
11569 reader, &e, true,
11570 )?));
11571 #[cfg(feature = "extra-children")]
11572 {
11573 child_idx += 1;
11574 }
11575 }
11576 #[cfg(feature = "pml-external")]
11577 b"webPr" => {
11578 f_web_pr =
11579 Some(Box::new(CTWebProperties::from_xml(reader, &e, true)?));
11580 #[cfg(feature = "extra-children")]
11581 {
11582 child_idx += 1;
11583 }
11584 }
11585 b"prnPr" => {
11586 f_prn_pr =
11587 Some(Box::new(CTPrintProperties::from_xml(reader, &e, true)?));
11588 #[cfg(feature = "extra-children")]
11589 {
11590 child_idx += 1;
11591 }
11592 }
11593 b"showPr" => {
11594 f_show_pr =
11595 Some(Box::new(CTShowProperties::from_xml(reader, &e, true)?));
11596 #[cfg(feature = "extra-children")]
11597 {
11598 child_idx += 1;
11599 }
11600 }
11601 #[cfg(feature = "pml-styling")]
11602 b"clrMru" => {
11603 f_clr_mru = Some(Box::new(ooxml_dml::types::CTColorMRU::from_xml(
11604 reader, &e, true,
11605 )?));
11606 #[cfg(feature = "extra-children")]
11607 {
11608 child_idx += 1;
11609 }
11610 }
11611 #[cfg(feature = "pml-extensions")]
11612 b"extLst" => {
11613 f_ext_lst =
11614 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
11615 #[cfg(feature = "extra-children")]
11616 {
11617 child_idx += 1;
11618 }
11619 }
11620 #[cfg(feature = "extra-children")]
11621 _ => {
11622 let elem = RawXmlElement::from_empty(&e);
11624 extra_children.push(PositionedNode::new(
11625 child_idx,
11626 RawXmlNode::Element(elem),
11627 ));
11628 child_idx += 1;
11629 }
11630 #[cfg(not(feature = "extra-children"))]
11631 _ => {}
11632 }
11633 }
11634 Event::End(_) => break,
11635 Event::Eof => break,
11636 _ => {}
11637 }
11638 buf.clear();
11639 }
11640 }
11641
11642 Ok(Self {
11643 #[cfg(feature = "pml-external")]
11644 html_pub_pr: f_html_pub_pr,
11645 #[cfg(feature = "pml-external")]
11646 web_pr: f_web_pr,
11647 prn_pr: f_prn_pr,
11648 show_pr: f_show_pr,
11649 #[cfg(feature = "pml-styling")]
11650 clr_mru: f_clr_mru,
11651 #[cfg(feature = "pml-extensions")]
11652 ext_lst: f_ext_lst,
11653 #[cfg(feature = "extra-children")]
11654 extra_children,
11655 })
11656 }
11657}
11658
11659impl FromXml for CTHeaderFooter {
11660 fn from_xml<R: BufRead>(
11661 reader: &mut Reader<R>,
11662 start_tag: &BytesStart,
11663 is_empty: bool,
11664 ) -> Result<Self, ParseError> {
11665 #[cfg(feature = "pml-masters")]
11666 let mut f_sld_num = None;
11667 #[cfg(feature = "pml-masters")]
11668 let mut f_hdr = None;
11669 #[cfg(feature = "pml-masters")]
11670 let mut f_ftr = None;
11671 #[cfg(feature = "pml-masters")]
11672 let mut f_dt = None;
11673 let mut f_ext_lst = None;
11674 #[cfg(feature = "extra-attrs")]
11675 let mut extra_attrs = std::collections::HashMap::new();
11676 #[cfg(feature = "extra-children")]
11677 let mut extra_children = Vec::new();
11678 #[cfg(feature = "extra-children")]
11679 let mut child_idx: usize = 0;
11680
11681 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
11683 let val = String::from_utf8_lossy(&attr.value);
11684 match attr.key.local_name().as_ref() {
11685 #[cfg(feature = "pml-masters")]
11686 b"sldNum" => {
11687 f_sld_num = Some(val == "true" || val == "1");
11688 }
11689 #[cfg(feature = "pml-masters")]
11690 b"hdr" => {
11691 f_hdr = Some(val == "true" || val == "1");
11692 }
11693 #[cfg(feature = "pml-masters")]
11694 b"ftr" => {
11695 f_ftr = Some(val == "true" || val == "1");
11696 }
11697 #[cfg(feature = "pml-masters")]
11698 b"dt" => {
11699 f_dt = Some(val == "true" || val == "1");
11700 }
11701 #[cfg(feature = "extra-attrs")]
11702 unknown => {
11703 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
11704 extra_attrs.insert(key, val.into_owned());
11705 }
11706 #[cfg(not(feature = "extra-attrs"))]
11707 _ => {}
11708 }
11709 }
11710
11711 if !is_empty {
11713 let mut buf = Vec::new();
11714 loop {
11715 match reader.read_event_into(&mut buf)? {
11716 Event::Start(e) => {
11717 match e.local_name().as_ref() {
11718 b"extLst" => {
11719 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
11720 reader, &e, false,
11721 )?));
11722 #[cfg(feature = "extra-children")]
11723 {
11724 child_idx += 1;
11725 }
11726 }
11727 #[cfg(feature = "extra-children")]
11728 _ => {
11729 let elem = RawXmlElement::from_reader(reader, &e)?;
11731 extra_children.push(PositionedNode::new(
11732 child_idx,
11733 RawXmlNode::Element(elem),
11734 ));
11735 child_idx += 1;
11736 }
11737 #[cfg(not(feature = "extra-children"))]
11738 _ => {
11739 skip_element(reader)?;
11741 }
11742 }
11743 }
11744 Event::Empty(e) => {
11745 match e.local_name().as_ref() {
11746 b"extLst" => {
11747 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
11748 reader, &e, true,
11749 )?));
11750 #[cfg(feature = "extra-children")]
11751 {
11752 child_idx += 1;
11753 }
11754 }
11755 #[cfg(feature = "extra-children")]
11756 _ => {
11757 let elem = RawXmlElement::from_empty(&e);
11759 extra_children.push(PositionedNode::new(
11760 child_idx,
11761 RawXmlNode::Element(elem),
11762 ));
11763 child_idx += 1;
11764 }
11765 #[cfg(not(feature = "extra-children"))]
11766 _ => {}
11767 }
11768 }
11769 Event::End(_) => break,
11770 Event::Eof => break,
11771 _ => {}
11772 }
11773 buf.clear();
11774 }
11775 }
11776
11777 Ok(Self {
11778 #[cfg(feature = "pml-masters")]
11779 sld_num: f_sld_num,
11780 #[cfg(feature = "pml-masters")]
11781 hdr: f_hdr,
11782 #[cfg(feature = "pml-masters")]
11783 ftr: f_ftr,
11784 #[cfg(feature = "pml-masters")]
11785 dt: f_dt,
11786 ext_lst: f_ext_lst,
11787 #[cfg(feature = "extra-attrs")]
11788 extra_attrs,
11789 #[cfg(feature = "extra-children")]
11790 extra_children,
11791 })
11792 }
11793}
11794
11795impl FromXml for CTPlaceholder {
11796 fn from_xml<R: BufRead>(
11797 reader: &mut Reader<R>,
11798 start_tag: &BytesStart,
11799 is_empty: bool,
11800 ) -> Result<Self, ParseError> {
11801 let mut f_type = None;
11802 let mut f_orient = None;
11803 let mut f_sz = None;
11804 let mut f_idx = None;
11805 let mut f_has_custom_prompt = None;
11806 let mut f_ext_lst = None;
11807 #[cfg(feature = "extra-attrs")]
11808 let mut extra_attrs = std::collections::HashMap::new();
11809 #[cfg(feature = "extra-children")]
11810 let mut extra_children = Vec::new();
11811 #[cfg(feature = "extra-children")]
11812 let mut child_idx: usize = 0;
11813
11814 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
11816 let val = String::from_utf8_lossy(&attr.value);
11817 match attr.key.local_name().as_ref() {
11818 b"type" => {
11819 f_type = val.parse().ok();
11820 }
11821 b"orient" => {
11822 f_orient = val.parse().ok();
11823 }
11824 b"sz" => {
11825 f_sz = val.parse().ok();
11826 }
11827 b"idx" => {
11828 f_idx = val.parse().ok();
11829 }
11830 b"hasCustomPrompt" => {
11831 f_has_custom_prompt = Some(val == "true" || val == "1");
11832 }
11833 #[cfg(feature = "extra-attrs")]
11834 unknown => {
11835 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
11836 extra_attrs.insert(key, val.into_owned());
11837 }
11838 #[cfg(not(feature = "extra-attrs"))]
11839 _ => {}
11840 }
11841 }
11842
11843 if !is_empty {
11845 let mut buf = Vec::new();
11846 loop {
11847 match reader.read_event_into(&mut buf)? {
11848 Event::Start(e) => {
11849 match e.local_name().as_ref() {
11850 b"extLst" => {
11851 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
11852 reader, &e, false,
11853 )?));
11854 #[cfg(feature = "extra-children")]
11855 {
11856 child_idx += 1;
11857 }
11858 }
11859 #[cfg(feature = "extra-children")]
11860 _ => {
11861 let elem = RawXmlElement::from_reader(reader, &e)?;
11863 extra_children.push(PositionedNode::new(
11864 child_idx,
11865 RawXmlNode::Element(elem),
11866 ));
11867 child_idx += 1;
11868 }
11869 #[cfg(not(feature = "extra-children"))]
11870 _ => {
11871 skip_element(reader)?;
11873 }
11874 }
11875 }
11876 Event::Empty(e) => {
11877 match e.local_name().as_ref() {
11878 b"extLst" => {
11879 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
11880 reader, &e, true,
11881 )?));
11882 #[cfg(feature = "extra-children")]
11883 {
11884 child_idx += 1;
11885 }
11886 }
11887 #[cfg(feature = "extra-children")]
11888 _ => {
11889 let elem = RawXmlElement::from_empty(&e);
11891 extra_children.push(PositionedNode::new(
11892 child_idx,
11893 RawXmlNode::Element(elem),
11894 ));
11895 child_idx += 1;
11896 }
11897 #[cfg(not(feature = "extra-children"))]
11898 _ => {}
11899 }
11900 }
11901 Event::End(_) => break,
11902 Event::Eof => break,
11903 _ => {}
11904 }
11905 buf.clear();
11906 }
11907 }
11908
11909 Ok(Self {
11910 r#type: f_type,
11911 orient: f_orient,
11912 sz: f_sz,
11913 idx: f_idx,
11914 has_custom_prompt: f_has_custom_prompt,
11915 ext_lst: f_ext_lst,
11916 #[cfg(feature = "extra-attrs")]
11917 extra_attrs,
11918 #[cfg(feature = "extra-children")]
11919 extra_children,
11920 })
11921 }
11922}
11923
11924impl FromXml for CTApplicationNonVisualDrawingProps {
11925 fn from_xml<R: BufRead>(
11926 reader: &mut Reader<R>,
11927 start_tag: &BytesStart,
11928 is_empty: bool,
11929 ) -> Result<Self, ParseError> {
11930 let mut f_is_photo = None;
11931 let mut f_user_drawn = None;
11932 let mut f_ph = None;
11933 let mut f_cust_data_lst = None;
11934 let mut f_ext_lst = None;
11935 #[cfg(feature = "extra-attrs")]
11936 let mut extra_attrs = std::collections::HashMap::new();
11937 #[cfg(feature = "extra-children")]
11938 let mut extra_children = Vec::new();
11939 #[cfg(feature = "extra-children")]
11940 let mut child_idx: usize = 0;
11941
11942 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
11944 let val = String::from_utf8_lossy(&attr.value);
11945 match attr.key.local_name().as_ref() {
11946 b"isPhoto" => {
11947 f_is_photo = Some(val == "true" || val == "1");
11948 }
11949 b"userDrawn" => {
11950 f_user_drawn = Some(val == "true" || val == "1");
11951 }
11952 #[cfg(feature = "extra-attrs")]
11953 unknown => {
11954 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
11955 extra_attrs.insert(key, val.into_owned());
11956 }
11957 #[cfg(not(feature = "extra-attrs"))]
11958 _ => {}
11959 }
11960 }
11961
11962 if !is_empty {
11964 let mut buf = Vec::new();
11965 loop {
11966 match reader.read_event_into(&mut buf)? {
11967 Event::Start(e) => {
11968 match e.local_name().as_ref() {
11969 b"ph" => {
11970 f_ph = Some(Box::new(CTPlaceholder::from_xml(reader, &e, false)?));
11971 #[cfg(feature = "extra-children")]
11972 {
11973 child_idx += 1;
11974 }
11975 }
11976 b"custDataLst" => {
11977 f_cust_data_lst = Some(Box::new(CTCustomerDataList::from_xml(
11978 reader, &e, false,
11979 )?));
11980 #[cfg(feature = "extra-children")]
11981 {
11982 child_idx += 1;
11983 }
11984 }
11985 b"extLst" => {
11986 f_ext_lst =
11987 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
11988 #[cfg(feature = "extra-children")]
11989 {
11990 child_idx += 1;
11991 }
11992 }
11993 #[cfg(feature = "extra-children")]
11994 _ => {
11995 let elem = RawXmlElement::from_reader(reader, &e)?;
11997 extra_children.push(PositionedNode::new(
11998 child_idx,
11999 RawXmlNode::Element(elem),
12000 ));
12001 child_idx += 1;
12002 }
12003 #[cfg(not(feature = "extra-children"))]
12004 _ => {
12005 skip_element(reader)?;
12007 }
12008 }
12009 }
12010 Event::Empty(e) => {
12011 match e.local_name().as_ref() {
12012 b"ph" => {
12013 f_ph = Some(Box::new(CTPlaceholder::from_xml(reader, &e, true)?));
12014 #[cfg(feature = "extra-children")]
12015 {
12016 child_idx += 1;
12017 }
12018 }
12019 b"custDataLst" => {
12020 f_cust_data_lst =
12021 Some(Box::new(CTCustomerDataList::from_xml(reader, &e, true)?));
12022 #[cfg(feature = "extra-children")]
12023 {
12024 child_idx += 1;
12025 }
12026 }
12027 b"extLst" => {
12028 f_ext_lst =
12029 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
12030 #[cfg(feature = "extra-children")]
12031 {
12032 child_idx += 1;
12033 }
12034 }
12035 #[cfg(feature = "extra-children")]
12036 _ => {
12037 let elem = RawXmlElement::from_empty(&e);
12039 extra_children.push(PositionedNode::new(
12040 child_idx,
12041 RawXmlNode::Element(elem),
12042 ));
12043 child_idx += 1;
12044 }
12045 #[cfg(not(feature = "extra-children"))]
12046 _ => {}
12047 }
12048 }
12049 Event::End(_) => break,
12050 Event::Eof => break,
12051 _ => {}
12052 }
12053 buf.clear();
12054 }
12055 }
12056
12057 Ok(Self {
12058 is_photo: f_is_photo,
12059 user_drawn: f_user_drawn,
12060 ph: f_ph,
12061 cust_data_lst: f_cust_data_lst,
12062 ext_lst: f_ext_lst,
12063 #[cfg(feature = "extra-attrs")]
12064 extra_attrs,
12065 #[cfg(feature = "extra-children")]
12066 extra_children,
12067 })
12068 }
12069}
12070
12071impl FromXml for ShapeNonVisual {
12072 fn from_xml<R: BufRead>(
12073 reader: &mut Reader<R>,
12074 start_tag: &BytesStart,
12075 is_empty: bool,
12076 ) -> Result<Self, ParseError> {
12077 let mut f_c_nv_pr: Option<Box<ooxml_dml::types::CTNonVisualDrawingProps>> = None;
12078 let mut f_c_nv_sp_pr: Option<Box<ooxml_dml::types::CTNonVisualDrawingShapeProps>> = None;
12079 let mut f_nv_pr: Option<Box<CTApplicationNonVisualDrawingProps>> = None;
12080 #[cfg(feature = "extra-children")]
12081 let mut extra_children = Vec::new();
12082 #[cfg(feature = "extra-children")]
12083 let mut child_idx: usize = 0;
12084
12085 if !is_empty {
12087 let mut buf = Vec::new();
12088 loop {
12089 match reader.read_event_into(&mut buf)? {
12090 Event::Start(e) => {
12091 match e.local_name().as_ref() {
12092 b"cNvPr" => {
12093 f_c_nv_pr = Some(Box::new(
12094 ooxml_dml::types::CTNonVisualDrawingProps::from_xml(
12095 reader, &e, false,
12096 )?,
12097 ));
12098 #[cfg(feature = "extra-children")]
12099 {
12100 child_idx += 1;
12101 }
12102 }
12103 b"cNvSpPr" => {
12104 f_c_nv_sp_pr = Some(Box::new(
12105 ooxml_dml::types::CTNonVisualDrawingShapeProps::from_xml(
12106 reader, &e, false,
12107 )?,
12108 ));
12109 #[cfg(feature = "extra-children")]
12110 {
12111 child_idx += 1;
12112 }
12113 }
12114 b"nvPr" => {
12115 f_nv_pr =
12116 Some(Box::new(CTApplicationNonVisualDrawingProps::from_xml(
12117 reader, &e, false,
12118 )?));
12119 #[cfg(feature = "extra-children")]
12120 {
12121 child_idx += 1;
12122 }
12123 }
12124 #[cfg(feature = "extra-children")]
12125 _ => {
12126 let elem = RawXmlElement::from_reader(reader, &e)?;
12128 extra_children.push(PositionedNode::new(
12129 child_idx,
12130 RawXmlNode::Element(elem),
12131 ));
12132 child_idx += 1;
12133 }
12134 #[cfg(not(feature = "extra-children"))]
12135 _ => {
12136 skip_element(reader)?;
12138 }
12139 }
12140 }
12141 Event::Empty(e) => {
12142 match e.local_name().as_ref() {
12143 b"cNvPr" => {
12144 f_c_nv_pr = Some(Box::new(
12145 ooxml_dml::types::CTNonVisualDrawingProps::from_xml(
12146 reader, &e, true,
12147 )?,
12148 ));
12149 #[cfg(feature = "extra-children")]
12150 {
12151 child_idx += 1;
12152 }
12153 }
12154 b"cNvSpPr" => {
12155 f_c_nv_sp_pr = Some(Box::new(
12156 ooxml_dml::types::CTNonVisualDrawingShapeProps::from_xml(
12157 reader, &e, true,
12158 )?,
12159 ));
12160 #[cfg(feature = "extra-children")]
12161 {
12162 child_idx += 1;
12163 }
12164 }
12165 b"nvPr" => {
12166 f_nv_pr = Some(Box::new(
12167 CTApplicationNonVisualDrawingProps::from_xml(reader, &e, true)?,
12168 ));
12169 #[cfg(feature = "extra-children")]
12170 {
12171 child_idx += 1;
12172 }
12173 }
12174 #[cfg(feature = "extra-children")]
12175 _ => {
12176 let elem = RawXmlElement::from_empty(&e);
12178 extra_children.push(PositionedNode::new(
12179 child_idx,
12180 RawXmlNode::Element(elem),
12181 ));
12182 child_idx += 1;
12183 }
12184 #[cfg(not(feature = "extra-children"))]
12185 _ => {}
12186 }
12187 }
12188 Event::End(_) => break,
12189 Event::Eof => break,
12190 _ => {}
12191 }
12192 buf.clear();
12193 }
12194 }
12195
12196 Ok(Self {
12197 c_nv_pr: f_c_nv_pr.ok_or_else(|| ParseError::MissingAttribute("cNvPr".to_string()))?,
12198 c_nv_sp_pr: f_c_nv_sp_pr
12199 .ok_or_else(|| ParseError::MissingAttribute("cNvSpPr".to_string()))?,
12200 nv_pr: f_nv_pr.ok_or_else(|| ParseError::MissingAttribute("nvPr".to_string()))?,
12201 #[cfg(feature = "extra-children")]
12202 extra_children,
12203 })
12204 }
12205}
12206
12207impl FromXml for Shape {
12208 fn from_xml<R: BufRead>(
12209 reader: &mut Reader<R>,
12210 start_tag: &BytesStart,
12211 is_empty: bool,
12212 ) -> Result<Self, ParseError> {
12213 #[cfg(feature = "pml-styling")]
12214 let mut f_use_bg_fill = None;
12215 let mut f_non_visual_properties: Option<Box<ShapeNonVisual>> = None;
12216 let mut f_shape_properties: Option<Box<ooxml_dml::types::CTShapeProperties>> = None;
12217 #[cfg(feature = "pml-styling")]
12218 let mut f_style = None;
12219 let mut f_text_body = None;
12220 #[cfg(feature = "pml-extensions")]
12221 let mut f_ext_lst = None;
12222 #[cfg(feature = "extra-attrs")]
12223 let mut extra_attrs = std::collections::HashMap::new();
12224 #[cfg(feature = "extra-children")]
12225 let mut extra_children = Vec::new();
12226 #[cfg(feature = "extra-children")]
12227 let mut child_idx: usize = 0;
12228
12229 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
12231 let val = String::from_utf8_lossy(&attr.value);
12232 match attr.key.local_name().as_ref() {
12233 #[cfg(feature = "pml-styling")]
12234 b"useBgFill" => {
12235 f_use_bg_fill = Some(val == "true" || val == "1");
12236 }
12237 #[cfg(feature = "extra-attrs")]
12238 unknown => {
12239 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
12240 extra_attrs.insert(key, val.into_owned());
12241 }
12242 #[cfg(not(feature = "extra-attrs"))]
12243 _ => {}
12244 }
12245 }
12246
12247 if !is_empty {
12249 let mut buf = Vec::new();
12250 loop {
12251 match reader.read_event_into(&mut buf)? {
12252 Event::Start(e) => {
12253 match e.local_name().as_ref() {
12254 b"nvSpPr" => {
12255 f_non_visual_properties =
12256 Some(Box::new(ShapeNonVisual::from_xml(reader, &e, false)?));
12257 #[cfg(feature = "extra-children")]
12258 {
12259 child_idx += 1;
12260 }
12261 }
12262 b"spPr" => {
12263 f_shape_properties =
12264 Some(Box::new(ooxml_dml::types::CTShapeProperties::from_xml(
12265 reader, &e, false,
12266 )?));
12267 #[cfg(feature = "extra-children")]
12268 {
12269 child_idx += 1;
12270 }
12271 }
12272 #[cfg(feature = "pml-styling")]
12273 b"style" => {
12274 f_style = Some(Box::new(ooxml_dml::types::ShapeStyle::from_xml(
12275 reader, &e, false,
12276 )?));
12277 #[cfg(feature = "extra-children")]
12278 {
12279 child_idx += 1;
12280 }
12281 }
12282 b"txBody" => {
12283 f_text_body = Some(Box::new(ooxml_dml::types::TextBody::from_xml(
12284 reader, &e, false,
12285 )?));
12286 #[cfg(feature = "extra-children")]
12287 {
12288 child_idx += 1;
12289 }
12290 }
12291 #[cfg(feature = "pml-extensions")]
12292 b"extLst" => {
12293 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
12294 reader, &e, false,
12295 )?));
12296 #[cfg(feature = "extra-children")]
12297 {
12298 child_idx += 1;
12299 }
12300 }
12301 #[cfg(feature = "extra-children")]
12302 _ => {
12303 let elem = RawXmlElement::from_reader(reader, &e)?;
12305 extra_children.push(PositionedNode::new(
12306 child_idx,
12307 RawXmlNode::Element(elem),
12308 ));
12309 child_idx += 1;
12310 }
12311 #[cfg(not(feature = "extra-children"))]
12312 _ => {
12313 skip_element(reader)?;
12315 }
12316 }
12317 }
12318 Event::Empty(e) => {
12319 match e.local_name().as_ref() {
12320 b"nvSpPr" => {
12321 f_non_visual_properties =
12322 Some(Box::new(ShapeNonVisual::from_xml(reader, &e, true)?));
12323 #[cfg(feature = "extra-children")]
12324 {
12325 child_idx += 1;
12326 }
12327 }
12328 b"spPr" => {
12329 f_shape_properties =
12330 Some(Box::new(ooxml_dml::types::CTShapeProperties::from_xml(
12331 reader, &e, true,
12332 )?));
12333 #[cfg(feature = "extra-children")]
12334 {
12335 child_idx += 1;
12336 }
12337 }
12338 #[cfg(feature = "pml-styling")]
12339 b"style" => {
12340 f_style = Some(Box::new(ooxml_dml::types::ShapeStyle::from_xml(
12341 reader, &e, true,
12342 )?));
12343 #[cfg(feature = "extra-children")]
12344 {
12345 child_idx += 1;
12346 }
12347 }
12348 b"txBody" => {
12349 f_text_body = Some(Box::new(ooxml_dml::types::TextBody::from_xml(
12350 reader, &e, true,
12351 )?));
12352 #[cfg(feature = "extra-children")]
12353 {
12354 child_idx += 1;
12355 }
12356 }
12357 #[cfg(feature = "pml-extensions")]
12358 b"extLst" => {
12359 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
12360 reader, &e, true,
12361 )?));
12362 #[cfg(feature = "extra-children")]
12363 {
12364 child_idx += 1;
12365 }
12366 }
12367 #[cfg(feature = "extra-children")]
12368 _ => {
12369 let elem = RawXmlElement::from_empty(&e);
12371 extra_children.push(PositionedNode::new(
12372 child_idx,
12373 RawXmlNode::Element(elem),
12374 ));
12375 child_idx += 1;
12376 }
12377 #[cfg(not(feature = "extra-children"))]
12378 _ => {}
12379 }
12380 }
12381 Event::End(_) => break,
12382 Event::Eof => break,
12383 _ => {}
12384 }
12385 buf.clear();
12386 }
12387 }
12388
12389 Ok(Self {
12390 #[cfg(feature = "pml-styling")]
12391 use_bg_fill: f_use_bg_fill,
12392 non_visual_properties: f_non_visual_properties
12393 .ok_or_else(|| ParseError::MissingAttribute("nvSpPr".to_string()))?,
12394 shape_properties: f_shape_properties
12395 .ok_or_else(|| ParseError::MissingAttribute("spPr".to_string()))?,
12396 #[cfg(feature = "pml-styling")]
12397 style: f_style,
12398 text_body: f_text_body,
12399 #[cfg(feature = "pml-extensions")]
12400 ext_lst: f_ext_lst,
12401 #[cfg(feature = "extra-attrs")]
12402 extra_attrs,
12403 #[cfg(feature = "extra-children")]
12404 extra_children,
12405 })
12406 }
12407}
12408
12409impl FromXml for CTConnectorNonVisual {
12410 fn from_xml<R: BufRead>(
12411 reader: &mut Reader<R>,
12412 start_tag: &BytesStart,
12413 is_empty: bool,
12414 ) -> Result<Self, ParseError> {
12415 let mut f_c_nv_pr: Option<Box<ooxml_dml::types::CTNonVisualDrawingProps>> = None;
12416 let mut f_c_nv_cxn_sp_pr: Option<Box<ooxml_dml::types::CTNonVisualConnectorProperties>> =
12417 None;
12418 let mut f_nv_pr: Option<Box<CTApplicationNonVisualDrawingProps>> = None;
12419 #[cfg(feature = "extra-children")]
12420 let mut extra_children = Vec::new();
12421 #[cfg(feature = "extra-children")]
12422 let mut child_idx: usize = 0;
12423
12424 if !is_empty {
12426 let mut buf = Vec::new();
12427 loop {
12428 match reader.read_event_into(&mut buf)? {
12429 Event::Start(e) => {
12430 match e.local_name().as_ref() {
12431 b"cNvPr" => {
12432 f_c_nv_pr = Some(Box::new(
12433 ooxml_dml::types::CTNonVisualDrawingProps::from_xml(
12434 reader, &e, false,
12435 )?,
12436 ));
12437 #[cfg(feature = "extra-children")]
12438 {
12439 child_idx += 1;
12440 }
12441 }
12442 b"cNvCxnSpPr" => {
12443 f_c_nv_cxn_sp_pr = Some(Box::new(
12444 ooxml_dml::types::CTNonVisualConnectorProperties::from_xml(
12445 reader, &e, false,
12446 )?,
12447 ));
12448 #[cfg(feature = "extra-children")]
12449 {
12450 child_idx += 1;
12451 }
12452 }
12453 b"nvPr" => {
12454 f_nv_pr =
12455 Some(Box::new(CTApplicationNonVisualDrawingProps::from_xml(
12456 reader, &e, false,
12457 )?));
12458 #[cfg(feature = "extra-children")]
12459 {
12460 child_idx += 1;
12461 }
12462 }
12463 #[cfg(feature = "extra-children")]
12464 _ => {
12465 let elem = RawXmlElement::from_reader(reader, &e)?;
12467 extra_children.push(PositionedNode::new(
12468 child_idx,
12469 RawXmlNode::Element(elem),
12470 ));
12471 child_idx += 1;
12472 }
12473 #[cfg(not(feature = "extra-children"))]
12474 _ => {
12475 skip_element(reader)?;
12477 }
12478 }
12479 }
12480 Event::Empty(e) => {
12481 match e.local_name().as_ref() {
12482 b"cNvPr" => {
12483 f_c_nv_pr = Some(Box::new(
12484 ooxml_dml::types::CTNonVisualDrawingProps::from_xml(
12485 reader, &e, true,
12486 )?,
12487 ));
12488 #[cfg(feature = "extra-children")]
12489 {
12490 child_idx += 1;
12491 }
12492 }
12493 b"cNvCxnSpPr" => {
12494 f_c_nv_cxn_sp_pr = Some(Box::new(
12495 ooxml_dml::types::CTNonVisualConnectorProperties::from_xml(
12496 reader, &e, true,
12497 )?,
12498 ));
12499 #[cfg(feature = "extra-children")]
12500 {
12501 child_idx += 1;
12502 }
12503 }
12504 b"nvPr" => {
12505 f_nv_pr = Some(Box::new(
12506 CTApplicationNonVisualDrawingProps::from_xml(reader, &e, true)?,
12507 ));
12508 #[cfg(feature = "extra-children")]
12509 {
12510 child_idx += 1;
12511 }
12512 }
12513 #[cfg(feature = "extra-children")]
12514 _ => {
12515 let elem = RawXmlElement::from_empty(&e);
12517 extra_children.push(PositionedNode::new(
12518 child_idx,
12519 RawXmlNode::Element(elem),
12520 ));
12521 child_idx += 1;
12522 }
12523 #[cfg(not(feature = "extra-children"))]
12524 _ => {}
12525 }
12526 }
12527 Event::End(_) => break,
12528 Event::Eof => break,
12529 _ => {}
12530 }
12531 buf.clear();
12532 }
12533 }
12534
12535 Ok(Self {
12536 c_nv_pr: f_c_nv_pr.ok_or_else(|| ParseError::MissingAttribute("cNvPr".to_string()))?,
12537 c_nv_cxn_sp_pr: f_c_nv_cxn_sp_pr
12538 .ok_or_else(|| ParseError::MissingAttribute("cNvCxnSpPr".to_string()))?,
12539 nv_pr: f_nv_pr.ok_or_else(|| ParseError::MissingAttribute("nvPr".to_string()))?,
12540 #[cfg(feature = "extra-children")]
12541 extra_children,
12542 })
12543 }
12544}
12545
12546impl FromXml for Connector {
12547 fn from_xml<R: BufRead>(
12548 reader: &mut Reader<R>,
12549 start_tag: &BytesStart,
12550 is_empty: bool,
12551 ) -> Result<Self, ParseError> {
12552 let mut f_non_visual_connector_properties: Option<Box<CTConnectorNonVisual>> = None;
12553 let mut f_shape_properties: Option<Box<ooxml_dml::types::CTShapeProperties>> = None;
12554 #[cfg(feature = "pml-styling")]
12555 let mut f_style = None;
12556 #[cfg(feature = "pml-extensions")]
12557 let mut f_ext_lst = None;
12558 #[cfg(feature = "extra-children")]
12559 let mut extra_children = Vec::new();
12560 #[cfg(feature = "extra-children")]
12561 let mut child_idx: usize = 0;
12562
12563 if !is_empty {
12565 let mut buf = Vec::new();
12566 loop {
12567 match reader.read_event_into(&mut buf)? {
12568 Event::Start(e) => {
12569 match e.local_name().as_ref() {
12570 b"nvCxnSpPr" => {
12571 f_non_visual_connector_properties = Some(Box::new(
12572 CTConnectorNonVisual::from_xml(reader, &e, false)?,
12573 ));
12574 #[cfg(feature = "extra-children")]
12575 {
12576 child_idx += 1;
12577 }
12578 }
12579 b"spPr" => {
12580 f_shape_properties =
12581 Some(Box::new(ooxml_dml::types::CTShapeProperties::from_xml(
12582 reader, &e, false,
12583 )?));
12584 #[cfg(feature = "extra-children")]
12585 {
12586 child_idx += 1;
12587 }
12588 }
12589 #[cfg(feature = "pml-styling")]
12590 b"style" => {
12591 f_style = Some(Box::new(ooxml_dml::types::ShapeStyle::from_xml(
12592 reader, &e, false,
12593 )?));
12594 #[cfg(feature = "extra-children")]
12595 {
12596 child_idx += 1;
12597 }
12598 }
12599 #[cfg(feature = "pml-extensions")]
12600 b"extLst" => {
12601 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
12602 reader, &e, false,
12603 )?));
12604 #[cfg(feature = "extra-children")]
12605 {
12606 child_idx += 1;
12607 }
12608 }
12609 #[cfg(feature = "extra-children")]
12610 _ => {
12611 let elem = RawXmlElement::from_reader(reader, &e)?;
12613 extra_children.push(PositionedNode::new(
12614 child_idx,
12615 RawXmlNode::Element(elem),
12616 ));
12617 child_idx += 1;
12618 }
12619 #[cfg(not(feature = "extra-children"))]
12620 _ => {
12621 skip_element(reader)?;
12623 }
12624 }
12625 }
12626 Event::Empty(e) => {
12627 match e.local_name().as_ref() {
12628 b"nvCxnSpPr" => {
12629 f_non_visual_connector_properties = Some(Box::new(
12630 CTConnectorNonVisual::from_xml(reader, &e, true)?,
12631 ));
12632 #[cfg(feature = "extra-children")]
12633 {
12634 child_idx += 1;
12635 }
12636 }
12637 b"spPr" => {
12638 f_shape_properties =
12639 Some(Box::new(ooxml_dml::types::CTShapeProperties::from_xml(
12640 reader, &e, true,
12641 )?));
12642 #[cfg(feature = "extra-children")]
12643 {
12644 child_idx += 1;
12645 }
12646 }
12647 #[cfg(feature = "pml-styling")]
12648 b"style" => {
12649 f_style = Some(Box::new(ooxml_dml::types::ShapeStyle::from_xml(
12650 reader, &e, true,
12651 )?));
12652 #[cfg(feature = "extra-children")]
12653 {
12654 child_idx += 1;
12655 }
12656 }
12657 #[cfg(feature = "pml-extensions")]
12658 b"extLst" => {
12659 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
12660 reader, &e, true,
12661 )?));
12662 #[cfg(feature = "extra-children")]
12663 {
12664 child_idx += 1;
12665 }
12666 }
12667 #[cfg(feature = "extra-children")]
12668 _ => {
12669 let elem = RawXmlElement::from_empty(&e);
12671 extra_children.push(PositionedNode::new(
12672 child_idx,
12673 RawXmlNode::Element(elem),
12674 ));
12675 child_idx += 1;
12676 }
12677 #[cfg(not(feature = "extra-children"))]
12678 _ => {}
12679 }
12680 }
12681 Event::End(_) => break,
12682 Event::Eof => break,
12683 _ => {}
12684 }
12685 buf.clear();
12686 }
12687 }
12688
12689 Ok(Self {
12690 non_visual_connector_properties: f_non_visual_connector_properties
12691 .ok_or_else(|| ParseError::MissingAttribute("nvCxnSpPr".to_string()))?,
12692 shape_properties: f_shape_properties
12693 .ok_or_else(|| ParseError::MissingAttribute("spPr".to_string()))?,
12694 #[cfg(feature = "pml-styling")]
12695 style: f_style,
12696 #[cfg(feature = "pml-extensions")]
12697 ext_lst: f_ext_lst,
12698 #[cfg(feature = "extra-children")]
12699 extra_children,
12700 })
12701 }
12702}
12703
12704impl FromXml for CTPictureNonVisual {
12705 fn from_xml<R: BufRead>(
12706 reader: &mut Reader<R>,
12707 start_tag: &BytesStart,
12708 is_empty: bool,
12709 ) -> Result<Self, ParseError> {
12710 let mut f_c_nv_pr: Option<Box<ooxml_dml::types::CTNonVisualDrawingProps>> = None;
12711 let mut f_c_nv_pic_pr: Option<Box<ooxml_dml::types::CTNonVisualPictureProperties>> = None;
12712 let mut f_nv_pr: Option<Box<CTApplicationNonVisualDrawingProps>> = None;
12713 #[cfg(feature = "extra-children")]
12714 let mut extra_children = Vec::new();
12715 #[cfg(feature = "extra-children")]
12716 let mut child_idx: usize = 0;
12717
12718 if !is_empty {
12720 let mut buf = Vec::new();
12721 loop {
12722 match reader.read_event_into(&mut buf)? {
12723 Event::Start(e) => {
12724 match e.local_name().as_ref() {
12725 b"cNvPr" => {
12726 f_c_nv_pr = Some(Box::new(
12727 ooxml_dml::types::CTNonVisualDrawingProps::from_xml(
12728 reader, &e, false,
12729 )?,
12730 ));
12731 #[cfg(feature = "extra-children")]
12732 {
12733 child_idx += 1;
12734 }
12735 }
12736 b"cNvPicPr" => {
12737 f_c_nv_pic_pr = Some(Box::new(
12738 ooxml_dml::types::CTNonVisualPictureProperties::from_xml(
12739 reader, &e, false,
12740 )?,
12741 ));
12742 #[cfg(feature = "extra-children")]
12743 {
12744 child_idx += 1;
12745 }
12746 }
12747 b"nvPr" => {
12748 f_nv_pr =
12749 Some(Box::new(CTApplicationNonVisualDrawingProps::from_xml(
12750 reader, &e, false,
12751 )?));
12752 #[cfg(feature = "extra-children")]
12753 {
12754 child_idx += 1;
12755 }
12756 }
12757 #[cfg(feature = "extra-children")]
12758 _ => {
12759 let elem = RawXmlElement::from_reader(reader, &e)?;
12761 extra_children.push(PositionedNode::new(
12762 child_idx,
12763 RawXmlNode::Element(elem),
12764 ));
12765 child_idx += 1;
12766 }
12767 #[cfg(not(feature = "extra-children"))]
12768 _ => {
12769 skip_element(reader)?;
12771 }
12772 }
12773 }
12774 Event::Empty(e) => {
12775 match e.local_name().as_ref() {
12776 b"cNvPr" => {
12777 f_c_nv_pr = Some(Box::new(
12778 ooxml_dml::types::CTNonVisualDrawingProps::from_xml(
12779 reader, &e, true,
12780 )?,
12781 ));
12782 #[cfg(feature = "extra-children")]
12783 {
12784 child_idx += 1;
12785 }
12786 }
12787 b"cNvPicPr" => {
12788 f_c_nv_pic_pr = Some(Box::new(
12789 ooxml_dml::types::CTNonVisualPictureProperties::from_xml(
12790 reader, &e, true,
12791 )?,
12792 ));
12793 #[cfg(feature = "extra-children")]
12794 {
12795 child_idx += 1;
12796 }
12797 }
12798 b"nvPr" => {
12799 f_nv_pr = Some(Box::new(
12800 CTApplicationNonVisualDrawingProps::from_xml(reader, &e, true)?,
12801 ));
12802 #[cfg(feature = "extra-children")]
12803 {
12804 child_idx += 1;
12805 }
12806 }
12807 #[cfg(feature = "extra-children")]
12808 _ => {
12809 let elem = RawXmlElement::from_empty(&e);
12811 extra_children.push(PositionedNode::new(
12812 child_idx,
12813 RawXmlNode::Element(elem),
12814 ));
12815 child_idx += 1;
12816 }
12817 #[cfg(not(feature = "extra-children"))]
12818 _ => {}
12819 }
12820 }
12821 Event::End(_) => break,
12822 Event::Eof => break,
12823 _ => {}
12824 }
12825 buf.clear();
12826 }
12827 }
12828
12829 Ok(Self {
12830 c_nv_pr: f_c_nv_pr.ok_or_else(|| ParseError::MissingAttribute("cNvPr".to_string()))?,
12831 c_nv_pic_pr: f_c_nv_pic_pr
12832 .ok_or_else(|| ParseError::MissingAttribute("cNvPicPr".to_string()))?,
12833 nv_pr: f_nv_pr.ok_or_else(|| ParseError::MissingAttribute("nvPr".to_string()))?,
12834 #[cfg(feature = "extra-children")]
12835 extra_children,
12836 })
12837 }
12838}
12839
12840impl FromXml for Picture {
12841 fn from_xml<R: BufRead>(
12842 reader: &mut Reader<R>,
12843 start_tag: &BytesStart,
12844 is_empty: bool,
12845 ) -> Result<Self, ParseError> {
12846 let mut f_non_visual_picture_properties: Option<Box<CTPictureNonVisual>> = None;
12847 let mut f_blip_fill: Option<Box<ooxml_dml::types::BlipFillProperties>> = None;
12848 let mut f_shape_properties: Option<Box<ooxml_dml::types::CTShapeProperties>> = None;
12849 #[cfg(feature = "pml-styling")]
12850 let mut f_style = None;
12851 #[cfg(feature = "pml-extensions")]
12852 let mut f_ext_lst = None;
12853 #[cfg(feature = "extra-children")]
12854 let mut extra_children = Vec::new();
12855 #[cfg(feature = "extra-children")]
12856 let mut child_idx: usize = 0;
12857
12858 if !is_empty {
12860 let mut buf = Vec::new();
12861 loop {
12862 match reader.read_event_into(&mut buf)? {
12863 Event::Start(e) => {
12864 match e.local_name().as_ref() {
12865 b"nvPicPr" => {
12866 f_non_visual_picture_properties = Some(Box::new(
12867 CTPictureNonVisual::from_xml(reader, &e, false)?,
12868 ));
12869 #[cfg(feature = "extra-children")]
12870 {
12871 child_idx += 1;
12872 }
12873 }
12874 b"blipFill" => {
12875 f_blip_fill =
12876 Some(Box::new(ooxml_dml::types::BlipFillProperties::from_xml(
12877 reader, &e, false,
12878 )?));
12879 #[cfg(feature = "extra-children")]
12880 {
12881 child_idx += 1;
12882 }
12883 }
12884 b"spPr" => {
12885 f_shape_properties =
12886 Some(Box::new(ooxml_dml::types::CTShapeProperties::from_xml(
12887 reader, &e, false,
12888 )?));
12889 #[cfg(feature = "extra-children")]
12890 {
12891 child_idx += 1;
12892 }
12893 }
12894 #[cfg(feature = "pml-styling")]
12895 b"style" => {
12896 f_style = Some(Box::new(ooxml_dml::types::ShapeStyle::from_xml(
12897 reader, &e, false,
12898 )?));
12899 #[cfg(feature = "extra-children")]
12900 {
12901 child_idx += 1;
12902 }
12903 }
12904 #[cfg(feature = "pml-extensions")]
12905 b"extLst" => {
12906 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
12907 reader, &e, false,
12908 )?));
12909 #[cfg(feature = "extra-children")]
12910 {
12911 child_idx += 1;
12912 }
12913 }
12914 #[cfg(feature = "extra-children")]
12915 _ => {
12916 let elem = RawXmlElement::from_reader(reader, &e)?;
12918 extra_children.push(PositionedNode::new(
12919 child_idx,
12920 RawXmlNode::Element(elem),
12921 ));
12922 child_idx += 1;
12923 }
12924 #[cfg(not(feature = "extra-children"))]
12925 _ => {
12926 skip_element(reader)?;
12928 }
12929 }
12930 }
12931 Event::Empty(e) => {
12932 match e.local_name().as_ref() {
12933 b"nvPicPr" => {
12934 f_non_visual_picture_properties =
12935 Some(Box::new(CTPictureNonVisual::from_xml(reader, &e, true)?));
12936 #[cfg(feature = "extra-children")]
12937 {
12938 child_idx += 1;
12939 }
12940 }
12941 b"blipFill" => {
12942 f_blip_fill =
12943 Some(Box::new(ooxml_dml::types::BlipFillProperties::from_xml(
12944 reader, &e, true,
12945 )?));
12946 #[cfg(feature = "extra-children")]
12947 {
12948 child_idx += 1;
12949 }
12950 }
12951 b"spPr" => {
12952 f_shape_properties =
12953 Some(Box::new(ooxml_dml::types::CTShapeProperties::from_xml(
12954 reader, &e, true,
12955 )?));
12956 #[cfg(feature = "extra-children")]
12957 {
12958 child_idx += 1;
12959 }
12960 }
12961 #[cfg(feature = "pml-styling")]
12962 b"style" => {
12963 f_style = Some(Box::new(ooxml_dml::types::ShapeStyle::from_xml(
12964 reader, &e, true,
12965 )?));
12966 #[cfg(feature = "extra-children")]
12967 {
12968 child_idx += 1;
12969 }
12970 }
12971 #[cfg(feature = "pml-extensions")]
12972 b"extLst" => {
12973 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
12974 reader, &e, true,
12975 )?));
12976 #[cfg(feature = "extra-children")]
12977 {
12978 child_idx += 1;
12979 }
12980 }
12981 #[cfg(feature = "extra-children")]
12982 _ => {
12983 let elem = RawXmlElement::from_empty(&e);
12985 extra_children.push(PositionedNode::new(
12986 child_idx,
12987 RawXmlNode::Element(elem),
12988 ));
12989 child_idx += 1;
12990 }
12991 #[cfg(not(feature = "extra-children"))]
12992 _ => {}
12993 }
12994 }
12995 Event::End(_) => break,
12996 Event::Eof => break,
12997 _ => {}
12998 }
12999 buf.clear();
13000 }
13001 }
13002
13003 Ok(Self {
13004 non_visual_picture_properties: f_non_visual_picture_properties
13005 .ok_or_else(|| ParseError::MissingAttribute("nvPicPr".to_string()))?,
13006 blip_fill: f_blip_fill
13007 .ok_or_else(|| ParseError::MissingAttribute("blipFill".to_string()))?,
13008 shape_properties: f_shape_properties
13009 .ok_or_else(|| ParseError::MissingAttribute("spPr".to_string()))?,
13010 #[cfg(feature = "pml-styling")]
13011 style: f_style,
13012 #[cfg(feature = "pml-extensions")]
13013 ext_lst: f_ext_lst,
13014 #[cfg(feature = "extra-children")]
13015 extra_children,
13016 })
13017 }
13018}
13019
13020impl FromXml for CTGraphicalObjectFrameNonVisual {
13021 fn from_xml<R: BufRead>(
13022 reader: &mut Reader<R>,
13023 start_tag: &BytesStart,
13024 is_empty: bool,
13025 ) -> Result<Self, ParseError> {
13026 let mut f_c_nv_pr: Option<Box<ooxml_dml::types::CTNonVisualDrawingProps>> = None;
13027 let mut f_c_nv_graphic_frame_pr: Option<
13028 Box<ooxml_dml::types::CTNonVisualGraphicFrameProperties>,
13029 > = None;
13030 let mut f_nv_pr: Option<Box<CTApplicationNonVisualDrawingProps>> = None;
13031 #[cfg(feature = "extra-children")]
13032 let mut extra_children = Vec::new();
13033 #[cfg(feature = "extra-children")]
13034 let mut child_idx: usize = 0;
13035
13036 if !is_empty {
13038 let mut buf = Vec::new();
13039 loop {
13040 match reader.read_event_into(&mut buf)? {
13041 Event::Start(e) => {
13042 match e.local_name().as_ref() {
13043 b"cNvPr" => {
13044 f_c_nv_pr = Some(Box::new(
13045 ooxml_dml::types::CTNonVisualDrawingProps::from_xml(
13046 reader, &e, false,
13047 )?,
13048 ));
13049 #[cfg(feature = "extra-children")]
13050 {
13051 child_idx += 1;
13052 }
13053 }
13054 b"cNvGraphicFramePr" => {
13055 f_c_nv_graphic_frame_pr = Some(Box::new(
13056 ooxml_dml::types::CTNonVisualGraphicFrameProperties::from_xml(
13057 reader, &e, false,
13058 )?,
13059 ));
13060 #[cfg(feature = "extra-children")]
13061 {
13062 child_idx += 1;
13063 }
13064 }
13065 b"nvPr" => {
13066 f_nv_pr =
13067 Some(Box::new(CTApplicationNonVisualDrawingProps::from_xml(
13068 reader, &e, false,
13069 )?));
13070 #[cfg(feature = "extra-children")]
13071 {
13072 child_idx += 1;
13073 }
13074 }
13075 #[cfg(feature = "extra-children")]
13076 _ => {
13077 let elem = RawXmlElement::from_reader(reader, &e)?;
13079 extra_children.push(PositionedNode::new(
13080 child_idx,
13081 RawXmlNode::Element(elem),
13082 ));
13083 child_idx += 1;
13084 }
13085 #[cfg(not(feature = "extra-children"))]
13086 _ => {
13087 skip_element(reader)?;
13089 }
13090 }
13091 }
13092 Event::Empty(e) => {
13093 match e.local_name().as_ref() {
13094 b"cNvPr" => {
13095 f_c_nv_pr = Some(Box::new(
13096 ooxml_dml::types::CTNonVisualDrawingProps::from_xml(
13097 reader, &e, true,
13098 )?,
13099 ));
13100 #[cfg(feature = "extra-children")]
13101 {
13102 child_idx += 1;
13103 }
13104 }
13105 b"cNvGraphicFramePr" => {
13106 f_c_nv_graphic_frame_pr = Some(Box::new(
13107 ooxml_dml::types::CTNonVisualGraphicFrameProperties::from_xml(
13108 reader, &e, true,
13109 )?,
13110 ));
13111 #[cfg(feature = "extra-children")]
13112 {
13113 child_idx += 1;
13114 }
13115 }
13116 b"nvPr" => {
13117 f_nv_pr = Some(Box::new(
13118 CTApplicationNonVisualDrawingProps::from_xml(reader, &e, true)?,
13119 ));
13120 #[cfg(feature = "extra-children")]
13121 {
13122 child_idx += 1;
13123 }
13124 }
13125 #[cfg(feature = "extra-children")]
13126 _ => {
13127 let elem = RawXmlElement::from_empty(&e);
13129 extra_children.push(PositionedNode::new(
13130 child_idx,
13131 RawXmlNode::Element(elem),
13132 ));
13133 child_idx += 1;
13134 }
13135 #[cfg(not(feature = "extra-children"))]
13136 _ => {}
13137 }
13138 }
13139 Event::End(_) => break,
13140 Event::Eof => break,
13141 _ => {}
13142 }
13143 buf.clear();
13144 }
13145 }
13146
13147 Ok(Self {
13148 c_nv_pr: f_c_nv_pr.ok_or_else(|| ParseError::MissingAttribute("cNvPr".to_string()))?,
13149 c_nv_graphic_frame_pr: f_c_nv_graphic_frame_pr
13150 .ok_or_else(|| ParseError::MissingAttribute("cNvGraphicFramePr".to_string()))?,
13151 nv_pr: f_nv_pr.ok_or_else(|| ParseError::MissingAttribute("nvPr".to_string()))?,
13152 #[cfg(feature = "extra-children")]
13153 extra_children,
13154 })
13155 }
13156}
13157
13158impl FromXml for GraphicalObjectFrame {
13159 fn from_xml<R: BufRead>(
13160 reader: &mut Reader<R>,
13161 start_tag: &BytesStart,
13162 is_empty: bool,
13163 ) -> Result<Self, ParseError> {
13164 #[cfg(feature = "pml-styling")]
13165 let mut f_bw_mode = None;
13166 let mut f_nv_graphic_frame_pr: Option<Box<CTGraphicalObjectFrameNonVisual>> = None;
13167 let mut f_xfrm: Option<Box<ooxml_dml::types::Transform2D>> = None;
13168 #[cfg(feature = "pml-extensions")]
13169 let mut f_ext_lst = None;
13170 #[cfg(feature = "extra-attrs")]
13171 let mut extra_attrs = std::collections::HashMap::new();
13172 #[cfg(feature = "extra-children")]
13173 let mut extra_children = Vec::new();
13174 #[cfg(feature = "extra-children")]
13175 let mut child_idx: usize = 0;
13176
13177 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
13179 let val = String::from_utf8_lossy(&attr.value);
13180 match attr.key.local_name().as_ref() {
13181 #[cfg(feature = "pml-styling")]
13182 b"bwMode" => {
13183 f_bw_mode = val.parse().ok();
13184 }
13185 #[cfg(feature = "extra-attrs")]
13186 unknown => {
13187 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
13188 extra_attrs.insert(key, val.into_owned());
13189 }
13190 #[cfg(not(feature = "extra-attrs"))]
13191 _ => {}
13192 }
13193 }
13194
13195 if !is_empty {
13197 let mut buf = Vec::new();
13198 loop {
13199 match reader.read_event_into(&mut buf)? {
13200 Event::Start(e) => {
13201 match e.local_name().as_ref() {
13202 b"nvGraphicFramePr" => {
13203 f_nv_graphic_frame_pr = Some(Box::new(
13204 CTGraphicalObjectFrameNonVisual::from_xml(reader, &e, false)?,
13205 ));
13206 #[cfg(feature = "extra-children")]
13207 {
13208 child_idx += 1;
13209 }
13210 }
13211 b"xfrm" => {
13212 f_xfrm = Some(Box::new(ooxml_dml::types::Transform2D::from_xml(
13213 reader, &e, false,
13214 )?));
13215 #[cfg(feature = "extra-children")]
13216 {
13217 child_idx += 1;
13218 }
13219 }
13220 #[cfg(feature = "pml-extensions")]
13221 b"extLst" => {
13222 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
13223 reader, &e, false,
13224 )?));
13225 #[cfg(feature = "extra-children")]
13226 {
13227 child_idx += 1;
13228 }
13229 }
13230 #[cfg(feature = "extra-children")]
13231 _ => {
13232 let elem = RawXmlElement::from_reader(reader, &e)?;
13234 extra_children.push(PositionedNode::new(
13235 child_idx,
13236 RawXmlNode::Element(elem),
13237 ));
13238 child_idx += 1;
13239 }
13240 #[cfg(not(feature = "extra-children"))]
13241 _ => {
13242 skip_element(reader)?;
13244 }
13245 }
13246 }
13247 Event::Empty(e) => {
13248 match e.local_name().as_ref() {
13249 b"nvGraphicFramePr" => {
13250 f_nv_graphic_frame_pr = Some(Box::new(
13251 CTGraphicalObjectFrameNonVisual::from_xml(reader, &e, true)?,
13252 ));
13253 #[cfg(feature = "extra-children")]
13254 {
13255 child_idx += 1;
13256 }
13257 }
13258 b"xfrm" => {
13259 f_xfrm = Some(Box::new(ooxml_dml::types::Transform2D::from_xml(
13260 reader, &e, true,
13261 )?));
13262 #[cfg(feature = "extra-children")]
13263 {
13264 child_idx += 1;
13265 }
13266 }
13267 #[cfg(feature = "pml-extensions")]
13268 b"extLst" => {
13269 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
13270 reader, &e, true,
13271 )?));
13272 #[cfg(feature = "extra-children")]
13273 {
13274 child_idx += 1;
13275 }
13276 }
13277 #[cfg(feature = "extra-children")]
13278 _ => {
13279 let elem = RawXmlElement::from_empty(&e);
13281 extra_children.push(PositionedNode::new(
13282 child_idx,
13283 RawXmlNode::Element(elem),
13284 ));
13285 child_idx += 1;
13286 }
13287 #[cfg(not(feature = "extra-children"))]
13288 _ => {}
13289 }
13290 }
13291 Event::End(_) => break,
13292 Event::Eof => break,
13293 _ => {}
13294 }
13295 buf.clear();
13296 }
13297 }
13298
13299 Ok(Self {
13300 #[cfg(feature = "pml-styling")]
13301 bw_mode: f_bw_mode,
13302 nv_graphic_frame_pr: f_nv_graphic_frame_pr
13303 .ok_or_else(|| ParseError::MissingAttribute("nvGraphicFramePr".to_string()))?,
13304 xfrm: f_xfrm.ok_or_else(|| ParseError::MissingAttribute("xfrm".to_string()))?,
13305 #[cfg(feature = "pml-extensions")]
13306 ext_lst: f_ext_lst,
13307 #[cfg(feature = "extra-attrs")]
13308 extra_attrs,
13309 #[cfg(feature = "extra-children")]
13310 extra_children,
13311 })
13312 }
13313}
13314
13315impl FromXml for CTGroupShapeNonVisual {
13316 fn from_xml<R: BufRead>(
13317 reader: &mut Reader<R>,
13318 start_tag: &BytesStart,
13319 is_empty: bool,
13320 ) -> Result<Self, ParseError> {
13321 let mut f_c_nv_pr: Option<Box<ooxml_dml::types::CTNonVisualDrawingProps>> = None;
13322 let mut f_c_nv_grp_sp_pr: Option<Box<ooxml_dml::types::CTNonVisualGroupDrawingShapeProps>> =
13323 None;
13324 let mut f_nv_pr: Option<Box<CTApplicationNonVisualDrawingProps>> = None;
13325 #[cfg(feature = "extra-children")]
13326 let mut extra_children = Vec::new();
13327 #[cfg(feature = "extra-children")]
13328 let mut child_idx: usize = 0;
13329
13330 if !is_empty {
13332 let mut buf = Vec::new();
13333 loop {
13334 match reader.read_event_into(&mut buf)? {
13335 Event::Start(e) => {
13336 match e.local_name().as_ref() {
13337 b"cNvPr" => {
13338 f_c_nv_pr = Some(Box::new(
13339 ooxml_dml::types::CTNonVisualDrawingProps::from_xml(
13340 reader, &e, false,
13341 )?,
13342 ));
13343 #[cfg(feature = "extra-children")]
13344 {
13345 child_idx += 1;
13346 }
13347 }
13348 b"cNvGrpSpPr" => {
13349 f_c_nv_grp_sp_pr = Some(Box::new(
13350 ooxml_dml::types::CTNonVisualGroupDrawingShapeProps::from_xml(
13351 reader, &e, false,
13352 )?,
13353 ));
13354 #[cfg(feature = "extra-children")]
13355 {
13356 child_idx += 1;
13357 }
13358 }
13359 b"nvPr" => {
13360 f_nv_pr =
13361 Some(Box::new(CTApplicationNonVisualDrawingProps::from_xml(
13362 reader, &e, false,
13363 )?));
13364 #[cfg(feature = "extra-children")]
13365 {
13366 child_idx += 1;
13367 }
13368 }
13369 #[cfg(feature = "extra-children")]
13370 _ => {
13371 let elem = RawXmlElement::from_reader(reader, &e)?;
13373 extra_children.push(PositionedNode::new(
13374 child_idx,
13375 RawXmlNode::Element(elem),
13376 ));
13377 child_idx += 1;
13378 }
13379 #[cfg(not(feature = "extra-children"))]
13380 _ => {
13381 skip_element(reader)?;
13383 }
13384 }
13385 }
13386 Event::Empty(e) => {
13387 match e.local_name().as_ref() {
13388 b"cNvPr" => {
13389 f_c_nv_pr = Some(Box::new(
13390 ooxml_dml::types::CTNonVisualDrawingProps::from_xml(
13391 reader, &e, true,
13392 )?,
13393 ));
13394 #[cfg(feature = "extra-children")]
13395 {
13396 child_idx += 1;
13397 }
13398 }
13399 b"cNvGrpSpPr" => {
13400 f_c_nv_grp_sp_pr = Some(Box::new(
13401 ooxml_dml::types::CTNonVisualGroupDrawingShapeProps::from_xml(
13402 reader, &e, true,
13403 )?,
13404 ));
13405 #[cfg(feature = "extra-children")]
13406 {
13407 child_idx += 1;
13408 }
13409 }
13410 b"nvPr" => {
13411 f_nv_pr = Some(Box::new(
13412 CTApplicationNonVisualDrawingProps::from_xml(reader, &e, true)?,
13413 ));
13414 #[cfg(feature = "extra-children")]
13415 {
13416 child_idx += 1;
13417 }
13418 }
13419 #[cfg(feature = "extra-children")]
13420 _ => {
13421 let elem = RawXmlElement::from_empty(&e);
13423 extra_children.push(PositionedNode::new(
13424 child_idx,
13425 RawXmlNode::Element(elem),
13426 ));
13427 child_idx += 1;
13428 }
13429 #[cfg(not(feature = "extra-children"))]
13430 _ => {}
13431 }
13432 }
13433 Event::End(_) => break,
13434 Event::Eof => break,
13435 _ => {}
13436 }
13437 buf.clear();
13438 }
13439 }
13440
13441 Ok(Self {
13442 c_nv_pr: f_c_nv_pr.ok_or_else(|| ParseError::MissingAttribute("cNvPr".to_string()))?,
13443 c_nv_grp_sp_pr: f_c_nv_grp_sp_pr
13444 .ok_or_else(|| ParseError::MissingAttribute("cNvGrpSpPr".to_string()))?,
13445 nv_pr: f_nv_pr.ok_or_else(|| ParseError::MissingAttribute("nvPr".to_string()))?,
13446 #[cfg(feature = "extra-children")]
13447 extra_children,
13448 })
13449 }
13450}
13451
13452impl FromXml for GroupShape {
13453 fn from_xml<R: BufRead>(
13454 reader: &mut Reader<R>,
13455 start_tag: &BytesStart,
13456 is_empty: bool,
13457 ) -> Result<Self, ParseError> {
13458 let mut f_non_visual_group_properties: Option<Box<CTGroupShapeNonVisual>> = None;
13459 let mut f_grp_sp_pr: Option<Box<ooxml_dml::types::CTGroupShapeProperties>> = None;
13460 let mut f_shape = Vec::new();
13461 let mut f_group_shape = Vec::new();
13462 let mut f_graphic_frame = Vec::new();
13463 let mut f_connector = Vec::new();
13464 let mut f_picture = Vec::new();
13465 #[cfg(feature = "pml-external")]
13466 let mut f_content_part = Vec::new();
13467 #[cfg(feature = "pml-extensions")]
13468 let mut f_ext_lst = None;
13469 #[cfg(feature = "extra-children")]
13470 let mut extra_children = Vec::new();
13471 #[cfg(feature = "extra-children")]
13472 let mut child_idx: usize = 0;
13473
13474 if !is_empty {
13476 let mut buf = Vec::new();
13477 loop {
13478 match reader.read_event_into(&mut buf)? {
13479 Event::Start(e) => {
13480 match e.local_name().as_ref() {
13481 b"nvGrpSpPr" => {
13482 f_non_visual_group_properties = Some(Box::new(
13483 CTGroupShapeNonVisual::from_xml(reader, &e, false)?,
13484 ));
13485 #[cfg(feature = "extra-children")]
13486 {
13487 child_idx += 1;
13488 }
13489 }
13490 b"grpSpPr" => {
13491 f_grp_sp_pr = Some(Box::new(
13492 ooxml_dml::types::CTGroupShapeProperties::from_xml(
13493 reader, &e, false,
13494 )?,
13495 ));
13496 #[cfg(feature = "extra-children")]
13497 {
13498 child_idx += 1;
13499 }
13500 }
13501 b"sp" => {
13502 f_shape.push(Shape::from_xml(reader, &e, false)?);
13503 #[cfg(feature = "extra-children")]
13504 {
13505 child_idx += 1;
13506 }
13507 }
13508 b"grpSp" => {
13509 f_group_shape.push(GroupShape::from_xml(reader, &e, false)?);
13510 #[cfg(feature = "extra-children")]
13511 {
13512 child_idx += 1;
13513 }
13514 }
13515 b"graphicFrame" => {
13516 f_graphic_frame
13517 .push(GraphicalObjectFrame::from_xml(reader, &e, false)?);
13518 #[cfg(feature = "extra-children")]
13519 {
13520 child_idx += 1;
13521 }
13522 }
13523 b"cxnSp" => {
13524 f_connector.push(Connector::from_xml(reader, &e, false)?);
13525 #[cfg(feature = "extra-children")]
13526 {
13527 child_idx += 1;
13528 }
13529 }
13530 b"pic" => {
13531 f_picture.push(Picture::from_xml(reader, &e, false)?);
13532 #[cfg(feature = "extra-children")]
13533 {
13534 child_idx += 1;
13535 }
13536 }
13537 #[cfg(feature = "pml-external")]
13538 b"contentPart" => {
13539 f_content_part.push(CTRel::from_xml(reader, &e, false)?);
13540 #[cfg(feature = "extra-children")]
13541 {
13542 child_idx += 1;
13543 }
13544 }
13545 #[cfg(feature = "pml-extensions")]
13546 b"extLst" => {
13547 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
13548 reader, &e, false,
13549 )?));
13550 #[cfg(feature = "extra-children")]
13551 {
13552 child_idx += 1;
13553 }
13554 }
13555 #[cfg(feature = "extra-children")]
13556 _ => {
13557 let elem = RawXmlElement::from_reader(reader, &e)?;
13559 extra_children.push(PositionedNode::new(
13560 child_idx,
13561 RawXmlNode::Element(elem),
13562 ));
13563 child_idx += 1;
13564 }
13565 #[cfg(not(feature = "extra-children"))]
13566 _ => {
13567 skip_element(reader)?;
13569 }
13570 }
13571 }
13572 Event::Empty(e) => {
13573 match e.local_name().as_ref() {
13574 b"nvGrpSpPr" => {
13575 f_non_visual_group_properties = Some(Box::new(
13576 CTGroupShapeNonVisual::from_xml(reader, &e, true)?,
13577 ));
13578 #[cfg(feature = "extra-children")]
13579 {
13580 child_idx += 1;
13581 }
13582 }
13583 b"grpSpPr" => {
13584 f_grp_sp_pr = Some(Box::new(
13585 ooxml_dml::types::CTGroupShapeProperties::from_xml(
13586 reader, &e, true,
13587 )?,
13588 ));
13589 #[cfg(feature = "extra-children")]
13590 {
13591 child_idx += 1;
13592 }
13593 }
13594 b"sp" => {
13595 f_shape.push(Shape::from_xml(reader, &e, true)?);
13596 #[cfg(feature = "extra-children")]
13597 {
13598 child_idx += 1;
13599 }
13600 }
13601 b"grpSp" => {
13602 f_group_shape.push(GroupShape::from_xml(reader, &e, true)?);
13603 #[cfg(feature = "extra-children")]
13604 {
13605 child_idx += 1;
13606 }
13607 }
13608 b"graphicFrame" => {
13609 f_graphic_frame
13610 .push(GraphicalObjectFrame::from_xml(reader, &e, true)?);
13611 #[cfg(feature = "extra-children")]
13612 {
13613 child_idx += 1;
13614 }
13615 }
13616 b"cxnSp" => {
13617 f_connector.push(Connector::from_xml(reader, &e, true)?);
13618 #[cfg(feature = "extra-children")]
13619 {
13620 child_idx += 1;
13621 }
13622 }
13623 b"pic" => {
13624 f_picture.push(Picture::from_xml(reader, &e, true)?);
13625 #[cfg(feature = "extra-children")]
13626 {
13627 child_idx += 1;
13628 }
13629 }
13630 #[cfg(feature = "pml-external")]
13631 b"contentPart" => {
13632 f_content_part.push(CTRel::from_xml(reader, &e, true)?);
13633 #[cfg(feature = "extra-children")]
13634 {
13635 child_idx += 1;
13636 }
13637 }
13638 #[cfg(feature = "pml-extensions")]
13639 b"extLst" => {
13640 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
13641 reader, &e, true,
13642 )?));
13643 #[cfg(feature = "extra-children")]
13644 {
13645 child_idx += 1;
13646 }
13647 }
13648 #[cfg(feature = "extra-children")]
13649 _ => {
13650 let elem = RawXmlElement::from_empty(&e);
13652 extra_children.push(PositionedNode::new(
13653 child_idx,
13654 RawXmlNode::Element(elem),
13655 ));
13656 child_idx += 1;
13657 }
13658 #[cfg(not(feature = "extra-children"))]
13659 _ => {}
13660 }
13661 }
13662 Event::End(_) => break,
13663 Event::Eof => break,
13664 _ => {}
13665 }
13666 buf.clear();
13667 }
13668 }
13669
13670 Ok(Self {
13671 non_visual_group_properties: f_non_visual_group_properties
13672 .ok_or_else(|| ParseError::MissingAttribute("nvGrpSpPr".to_string()))?,
13673 grp_sp_pr: f_grp_sp_pr
13674 .ok_or_else(|| ParseError::MissingAttribute("grpSpPr".to_string()))?,
13675 shape: f_shape,
13676 group_shape: f_group_shape,
13677 graphic_frame: f_graphic_frame,
13678 connector: f_connector,
13679 picture: f_picture,
13680 #[cfg(feature = "pml-external")]
13681 content_part: f_content_part,
13682 #[cfg(feature = "pml-extensions")]
13683 ext_lst: f_ext_lst,
13684 #[cfg(feature = "extra-children")]
13685 extra_children,
13686 })
13687 }
13688}
13689
13690impl FromXml for CTRel {
13691 fn from_xml<R: BufRead>(
13692 reader: &mut Reader<R>,
13693 start_tag: &BytesStart,
13694 is_empty: bool,
13695 ) -> Result<Self, ParseError> {
13696 #[cfg(feature = "extra-children")]
13697 let mut extra_children = Vec::new();
13698 #[cfg(feature = "extra-children")]
13699 let mut child_idx: usize = 0;
13700 if !is_empty {
13701 let mut buf = Vec::new();
13702 loop {
13703 match reader.read_event_into(&mut buf)? {
13704 #[cfg(feature = "extra-children")]
13705 Event::Start(e) => {
13706 let elem = RawXmlElement::from_reader(reader, &e)?;
13707 extra_children
13708 .push(PositionedNode::new(child_idx, RawXmlNode::Element(elem)));
13709 child_idx += 1;
13710 }
13711 #[cfg(not(feature = "extra-children"))]
13712 Event::Start(_) => {
13713 skip_element(reader)?;
13714 }
13715 #[cfg(feature = "extra-children")]
13716 Event::Empty(e) => {
13717 let elem = RawXmlElement::from_empty(&e);
13718 extra_children
13719 .push(PositionedNode::new(child_idx, RawXmlNode::Element(elem)));
13720 child_idx += 1;
13721 }
13722 #[cfg(not(feature = "extra-children"))]
13723 Event::Empty(_) => {}
13724 Event::End(_) => break,
13725 Event::Eof => break,
13726 _ => {}
13727 }
13728 buf.clear();
13729 }
13730 }
13731 Ok(Self {
13732 #[cfg(feature = "extra-children")]
13733 extra_children,
13734 })
13735 }
13736}
13737
13738impl FromXml for EGChildSlide {
13739 fn from_xml<R: BufRead>(
13740 reader: &mut Reader<R>,
13741 start_tag: &BytesStart,
13742 is_empty: bool,
13743 ) -> Result<Self, ParseError> {
13744 let mut f_clr_map_ovr = None;
13745 #[cfg(feature = "extra-children")]
13746 let mut extra_children = Vec::new();
13747 #[cfg(feature = "extra-children")]
13748 let mut child_idx: usize = 0;
13749
13750 if !is_empty {
13752 let mut buf = Vec::new();
13753 loop {
13754 match reader.read_event_into(&mut buf)? {
13755 Event::Start(e) => {
13756 match e.local_name().as_ref() {
13757 b"clrMapOvr" => {
13758 f_clr_map_ovr = Some(Box::new(
13759 ooxml_dml::types::CTColorMappingOverride::from_xml(
13760 reader, &e, false,
13761 )?,
13762 ));
13763 #[cfg(feature = "extra-children")]
13764 {
13765 child_idx += 1;
13766 }
13767 }
13768 #[cfg(feature = "extra-children")]
13769 _ => {
13770 let elem = RawXmlElement::from_reader(reader, &e)?;
13772 extra_children.push(PositionedNode::new(
13773 child_idx,
13774 RawXmlNode::Element(elem),
13775 ));
13776 child_idx += 1;
13777 }
13778 #[cfg(not(feature = "extra-children"))]
13779 _ => {
13780 skip_element(reader)?;
13782 }
13783 }
13784 }
13785 Event::Empty(e) => {
13786 match e.local_name().as_ref() {
13787 b"clrMapOvr" => {
13788 f_clr_map_ovr = Some(Box::new(
13789 ooxml_dml::types::CTColorMappingOverride::from_xml(
13790 reader, &e, true,
13791 )?,
13792 ));
13793 #[cfg(feature = "extra-children")]
13794 {
13795 child_idx += 1;
13796 }
13797 }
13798 #[cfg(feature = "extra-children")]
13799 _ => {
13800 let elem = RawXmlElement::from_empty(&e);
13802 extra_children.push(PositionedNode::new(
13803 child_idx,
13804 RawXmlNode::Element(elem),
13805 ));
13806 child_idx += 1;
13807 }
13808 #[cfg(not(feature = "extra-children"))]
13809 _ => {}
13810 }
13811 }
13812 Event::End(_) => break,
13813 Event::Eof => break,
13814 _ => {}
13815 }
13816 buf.clear();
13817 }
13818 }
13819
13820 Ok(Self {
13821 clr_map_ovr: f_clr_map_ovr,
13822 #[cfg(feature = "extra-children")]
13823 extra_children,
13824 })
13825 }
13826}
13827
13828impl FromXml for PAGChildSlide {
13829 fn from_xml<R: BufRead>(
13830 reader: &mut Reader<R>,
13831 start_tag: &BytesStart,
13832 is_empty: bool,
13833 ) -> Result<Self, ParseError> {
13834 let mut f_show_master_sp = None;
13835 let mut f_show_master_ph_anim = None;
13836 #[cfg(feature = "extra-attrs")]
13837 let mut extra_attrs = std::collections::HashMap::new();
13838
13839 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
13841 let val = String::from_utf8_lossy(&attr.value);
13842 match attr.key.local_name().as_ref() {
13843 b"showMasterSp" => {
13844 f_show_master_sp = Some(val == "true" || val == "1");
13845 }
13846 b"showMasterPhAnim" => {
13847 f_show_master_ph_anim = Some(val == "true" || val == "1");
13848 }
13849 #[cfg(feature = "extra-attrs")]
13850 unknown => {
13851 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
13852 extra_attrs.insert(key, val.into_owned());
13853 }
13854 #[cfg(not(feature = "extra-attrs"))]
13855 _ => {}
13856 }
13857 }
13858
13859 if !is_empty {
13860 let mut buf = Vec::new();
13861 loop {
13862 match reader.read_event_into(&mut buf)? {
13863 Event::End(_) => break,
13864 Event::Eof => break,
13865 _ => {}
13866 }
13867 buf.clear();
13868 }
13869 }
13870
13871 Ok(Self {
13872 show_master_sp: f_show_master_sp,
13873 show_master_ph_anim: f_show_master_ph_anim,
13874 #[cfg(feature = "extra-attrs")]
13875 extra_attrs,
13876 })
13877 }
13878}
13879
13880impl FromXml for CTBackgroundProperties {
13881 fn from_xml<R: BufRead>(
13882 reader: &mut Reader<R>,
13883 start_tag: &BytesStart,
13884 is_empty: bool,
13885 ) -> Result<Self, ParseError> {
13886 let mut f_shade_to_title = None;
13887 let mut f_ext_lst = None;
13888 #[cfg(feature = "extra-attrs")]
13889 let mut extra_attrs = std::collections::HashMap::new();
13890 #[cfg(feature = "extra-children")]
13891 let mut extra_children = Vec::new();
13892 #[cfg(feature = "extra-children")]
13893 let mut child_idx: usize = 0;
13894
13895 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
13897 let val = String::from_utf8_lossy(&attr.value);
13898 match attr.key.local_name().as_ref() {
13899 b"shadeToTitle" => {
13900 f_shade_to_title = Some(val == "true" || val == "1");
13901 }
13902 #[cfg(feature = "extra-attrs")]
13903 unknown => {
13904 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
13905 extra_attrs.insert(key, val.into_owned());
13906 }
13907 #[cfg(not(feature = "extra-attrs"))]
13908 _ => {}
13909 }
13910 }
13911
13912 if !is_empty {
13914 let mut buf = Vec::new();
13915 loop {
13916 match reader.read_event_into(&mut buf)? {
13917 Event::Start(e) => {
13918 match e.local_name().as_ref() {
13919 b"extLst" => {
13920 f_ext_lst =
13921 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
13922 #[cfg(feature = "extra-children")]
13923 {
13924 child_idx += 1;
13925 }
13926 }
13927 #[cfg(feature = "extra-children")]
13928 _ => {
13929 let elem = RawXmlElement::from_reader(reader, &e)?;
13931 extra_children.push(PositionedNode::new(
13932 child_idx,
13933 RawXmlNode::Element(elem),
13934 ));
13935 child_idx += 1;
13936 }
13937 #[cfg(not(feature = "extra-children"))]
13938 _ => {
13939 skip_element(reader)?;
13941 }
13942 }
13943 }
13944 Event::Empty(e) => {
13945 match e.local_name().as_ref() {
13946 b"extLst" => {
13947 f_ext_lst =
13948 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
13949 #[cfg(feature = "extra-children")]
13950 {
13951 child_idx += 1;
13952 }
13953 }
13954 #[cfg(feature = "extra-children")]
13955 _ => {
13956 let elem = RawXmlElement::from_empty(&e);
13958 extra_children.push(PositionedNode::new(
13959 child_idx,
13960 RawXmlNode::Element(elem),
13961 ));
13962 child_idx += 1;
13963 }
13964 #[cfg(not(feature = "extra-children"))]
13965 _ => {}
13966 }
13967 }
13968 Event::End(_) => break,
13969 Event::Eof => break,
13970 _ => {}
13971 }
13972 buf.clear();
13973 }
13974 }
13975
13976 Ok(Self {
13977 shade_to_title: f_shade_to_title,
13978 ext_lst: f_ext_lst,
13979 #[cfg(feature = "extra-attrs")]
13980 extra_attrs,
13981 #[cfg(feature = "extra-children")]
13982 extra_children,
13983 })
13984 }
13985}
13986
13987impl FromXml for EGBackground {
13988 fn from_xml<R: BufRead>(
13989 reader: &mut Reader<R>,
13990 start_tag: &BytesStart,
13991 is_empty: bool,
13992 ) -> Result<Self, ParseError> {
13993 let tag = start_tag.local_name();
13994 match tag.as_ref() {
13995 b"bgPr" => {
13996 let inner = CTBackgroundProperties::from_xml(reader, start_tag, is_empty)?;
13997 Ok(Self::BgPr(Box::new(inner)))
13998 }
13999 b"bgRef" => {
14000 let inner = ooxml_dml::types::CTStyleMatrixReference::from_xml(
14001 reader, start_tag, is_empty,
14002 )?;
14003 Ok(Self::BgRef(Box::new(inner)))
14004 }
14005 _ => Err(ParseError::UnexpectedElement(
14006 String::from_utf8_lossy(start_tag.name().as_ref()).into_owned(),
14007 )),
14008 }
14009 }
14010}
14011
14012impl FromXml for CTBackground {
14013 fn from_xml<R: BufRead>(
14014 reader: &mut Reader<R>,
14015 start_tag: &BytesStart,
14016 is_empty: bool,
14017 ) -> Result<Self, ParseError> {
14018 #[cfg(feature = "pml-styling")]
14019 let mut f_bw_mode = None;
14020 let mut f_background: Option<Box<EGBackground>> = None;
14021 #[cfg(feature = "extra-attrs")]
14022 let mut extra_attrs = std::collections::HashMap::new();
14023 #[cfg(feature = "extra-children")]
14024 let mut extra_children = Vec::new();
14025 #[cfg(feature = "extra-children")]
14026 let mut child_idx: usize = 0;
14027
14028 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
14030 let val = String::from_utf8_lossy(&attr.value);
14031 match attr.key.local_name().as_ref() {
14032 #[cfg(feature = "pml-styling")]
14033 b"bwMode" => {
14034 f_bw_mode = val.parse().ok();
14035 }
14036 #[cfg(feature = "extra-attrs")]
14037 unknown => {
14038 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
14039 extra_attrs.insert(key, val.into_owned());
14040 }
14041 #[cfg(not(feature = "extra-attrs"))]
14042 _ => {}
14043 }
14044 }
14045
14046 if !is_empty {
14048 let mut buf = Vec::new();
14049 loop {
14050 match reader.read_event_into(&mut buf)? {
14051 Event::Start(e) => {
14052 match e.local_name().as_ref() {
14053 b"bgPr" | b"bgRef" => {
14054 f_background =
14055 Some(Box::new(EGBackground::from_xml(reader, &e, false)?));
14056 #[cfg(feature = "extra-children")]
14057 {
14058 child_idx += 1;
14059 }
14060 }
14061 #[cfg(feature = "extra-children")]
14062 _ => {
14063 let elem = RawXmlElement::from_reader(reader, &e)?;
14065 extra_children.push(PositionedNode::new(
14066 child_idx,
14067 RawXmlNode::Element(elem),
14068 ));
14069 child_idx += 1;
14070 }
14071 #[cfg(not(feature = "extra-children"))]
14072 _ => {
14073 skip_element(reader)?;
14075 }
14076 }
14077 }
14078 Event::Empty(e) => {
14079 match e.local_name().as_ref() {
14080 b"bgPr" | b"bgRef" => {
14081 f_background =
14082 Some(Box::new(EGBackground::from_xml(reader, &e, true)?));
14083 #[cfg(feature = "extra-children")]
14084 {
14085 child_idx += 1;
14086 }
14087 }
14088 #[cfg(feature = "extra-children")]
14089 _ => {
14090 let elem = RawXmlElement::from_empty(&e);
14092 extra_children.push(PositionedNode::new(
14093 child_idx,
14094 RawXmlNode::Element(elem),
14095 ));
14096 child_idx += 1;
14097 }
14098 #[cfg(not(feature = "extra-children"))]
14099 _ => {}
14100 }
14101 }
14102 Event::End(_) => break,
14103 Event::Eof => break,
14104 _ => {}
14105 }
14106 buf.clear();
14107 }
14108 }
14109
14110 Ok(Self {
14111 #[cfg(feature = "pml-styling")]
14112 bw_mode: f_bw_mode,
14113 background: f_background,
14114 #[cfg(feature = "extra-attrs")]
14115 extra_attrs,
14116 #[cfg(feature = "extra-children")]
14117 extra_children,
14118 })
14119 }
14120}
14121
14122impl FromXml for CommonSlideData {
14123 fn from_xml<R: BufRead>(
14124 reader: &mut Reader<R>,
14125 start_tag: &BytesStart,
14126 is_empty: bool,
14127 ) -> Result<Self, ParseError> {
14128 let mut f_name = None;
14129 #[cfg(feature = "pml-styling")]
14130 let mut f_bg = None;
14131 let mut f_shape_tree: Option<Box<GroupShape>> = None;
14132 #[cfg(feature = "pml-external")]
14133 let mut f_cust_data_lst = None;
14134 #[cfg(feature = "pml-external")]
14135 let mut f_controls = None;
14136 #[cfg(feature = "pml-extensions")]
14137 let mut f_ext_lst = None;
14138 #[cfg(feature = "extra-attrs")]
14139 let mut extra_attrs = std::collections::HashMap::new();
14140 #[cfg(feature = "extra-children")]
14141 let mut extra_children = Vec::new();
14142 #[cfg(feature = "extra-children")]
14143 let mut child_idx: usize = 0;
14144
14145 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
14147 let val = String::from_utf8_lossy(&attr.value);
14148 match attr.key.local_name().as_ref() {
14149 b"name" => {
14150 f_name = Some(val.into_owned());
14151 }
14152 #[cfg(feature = "extra-attrs")]
14153 unknown => {
14154 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
14155 extra_attrs.insert(key, val.into_owned());
14156 }
14157 #[cfg(not(feature = "extra-attrs"))]
14158 _ => {}
14159 }
14160 }
14161
14162 if !is_empty {
14164 let mut buf = Vec::new();
14165 loop {
14166 match reader.read_event_into(&mut buf)? {
14167 Event::Start(e) => {
14168 match e.local_name().as_ref() {
14169 #[cfg(feature = "pml-styling")]
14170 b"bg" => {
14171 f_bg = Some(Box::new(CTBackground::from_xml(reader, &e, false)?));
14172 #[cfg(feature = "extra-children")]
14173 {
14174 child_idx += 1;
14175 }
14176 }
14177 b"spTree" => {
14178 f_shape_tree =
14179 Some(Box::new(GroupShape::from_xml(reader, &e, false)?));
14180 #[cfg(feature = "extra-children")]
14181 {
14182 child_idx += 1;
14183 }
14184 }
14185 #[cfg(feature = "pml-external")]
14186 b"custDataLst" => {
14187 f_cust_data_lst = Some(Box::new(CTCustomerDataList::from_xml(
14188 reader, &e, false,
14189 )?));
14190 #[cfg(feature = "extra-children")]
14191 {
14192 child_idx += 1;
14193 }
14194 }
14195 #[cfg(feature = "pml-external")]
14196 b"controls" => {
14197 f_controls =
14198 Some(Box::new(CTControlList::from_xml(reader, &e, false)?));
14199 #[cfg(feature = "extra-children")]
14200 {
14201 child_idx += 1;
14202 }
14203 }
14204 #[cfg(feature = "pml-extensions")]
14205 b"extLst" => {
14206 f_ext_lst =
14207 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
14208 #[cfg(feature = "extra-children")]
14209 {
14210 child_idx += 1;
14211 }
14212 }
14213 #[cfg(feature = "extra-children")]
14214 _ => {
14215 let elem = RawXmlElement::from_reader(reader, &e)?;
14217 extra_children.push(PositionedNode::new(
14218 child_idx,
14219 RawXmlNode::Element(elem),
14220 ));
14221 child_idx += 1;
14222 }
14223 #[cfg(not(feature = "extra-children"))]
14224 _ => {
14225 skip_element(reader)?;
14227 }
14228 }
14229 }
14230 Event::Empty(e) => {
14231 match e.local_name().as_ref() {
14232 #[cfg(feature = "pml-styling")]
14233 b"bg" => {
14234 f_bg = Some(Box::new(CTBackground::from_xml(reader, &e, true)?));
14235 #[cfg(feature = "extra-children")]
14236 {
14237 child_idx += 1;
14238 }
14239 }
14240 b"spTree" => {
14241 f_shape_tree =
14242 Some(Box::new(GroupShape::from_xml(reader, &e, true)?));
14243 #[cfg(feature = "extra-children")]
14244 {
14245 child_idx += 1;
14246 }
14247 }
14248 #[cfg(feature = "pml-external")]
14249 b"custDataLst" => {
14250 f_cust_data_lst =
14251 Some(Box::new(CTCustomerDataList::from_xml(reader, &e, true)?));
14252 #[cfg(feature = "extra-children")]
14253 {
14254 child_idx += 1;
14255 }
14256 }
14257 #[cfg(feature = "pml-external")]
14258 b"controls" => {
14259 f_controls =
14260 Some(Box::new(CTControlList::from_xml(reader, &e, true)?));
14261 #[cfg(feature = "extra-children")]
14262 {
14263 child_idx += 1;
14264 }
14265 }
14266 #[cfg(feature = "pml-extensions")]
14267 b"extLst" => {
14268 f_ext_lst =
14269 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
14270 #[cfg(feature = "extra-children")]
14271 {
14272 child_idx += 1;
14273 }
14274 }
14275 #[cfg(feature = "extra-children")]
14276 _ => {
14277 let elem = RawXmlElement::from_empty(&e);
14279 extra_children.push(PositionedNode::new(
14280 child_idx,
14281 RawXmlNode::Element(elem),
14282 ));
14283 child_idx += 1;
14284 }
14285 #[cfg(not(feature = "extra-children"))]
14286 _ => {}
14287 }
14288 }
14289 Event::End(_) => break,
14290 Event::Eof => break,
14291 _ => {}
14292 }
14293 buf.clear();
14294 }
14295 }
14296
14297 Ok(Self {
14298 name: f_name,
14299 #[cfg(feature = "pml-styling")]
14300 bg: f_bg,
14301 shape_tree: f_shape_tree
14302 .ok_or_else(|| ParseError::MissingAttribute("spTree".to_string()))?,
14303 #[cfg(feature = "pml-external")]
14304 cust_data_lst: f_cust_data_lst,
14305 #[cfg(feature = "pml-external")]
14306 controls: f_controls,
14307 #[cfg(feature = "pml-extensions")]
14308 ext_lst: f_ext_lst,
14309 #[cfg(feature = "extra-attrs")]
14310 extra_attrs,
14311 #[cfg(feature = "extra-children")]
14312 extra_children,
14313 })
14314 }
14315}
14316
14317impl FromXml for Slide {
14318 fn from_xml<R: BufRead>(
14319 reader: &mut Reader<R>,
14320 start_tag: &BytesStart,
14321 is_empty: bool,
14322 ) -> Result<Self, ParseError> {
14323 #[cfg(feature = "pml-masters")]
14324 let mut f_show_master_sp = None;
14325 #[cfg(feature = "pml-masters")]
14326 let mut f_show_master_ph_anim = None;
14327 let mut f_show = None;
14328 let mut f_common_slide_data: Option<Box<CommonSlideData>> = None;
14329 #[cfg(feature = "pml-styling")]
14330 let mut f_clr_map_ovr = None;
14331 #[cfg(feature = "pml-transitions")]
14332 let mut f_transition = None;
14333 #[cfg(feature = "pml-animations")]
14334 let mut f_timing = None;
14335 #[cfg(feature = "pml-extensions")]
14336 let mut f_ext_lst = None;
14337 #[cfg(feature = "extra-attrs")]
14338 let mut extra_attrs = std::collections::HashMap::new();
14339 #[cfg(feature = "extra-children")]
14340 let mut extra_children = Vec::new();
14341 #[cfg(feature = "extra-children")]
14342 let mut child_idx: usize = 0;
14343
14344 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
14346 let val = String::from_utf8_lossy(&attr.value);
14347 match attr.key.local_name().as_ref() {
14348 #[cfg(feature = "pml-masters")]
14349 b"showMasterSp" => {
14350 f_show_master_sp = Some(val == "true" || val == "1");
14351 }
14352 #[cfg(feature = "pml-masters")]
14353 b"showMasterPhAnim" => {
14354 f_show_master_ph_anim = Some(val == "true" || val == "1");
14355 }
14356 b"show" => {
14357 f_show = Some(val == "true" || val == "1");
14358 }
14359 #[cfg(feature = "extra-attrs")]
14360 unknown => {
14361 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
14362 extra_attrs.insert(key, val.into_owned());
14363 }
14364 #[cfg(not(feature = "extra-attrs"))]
14365 _ => {}
14366 }
14367 }
14368
14369 if !is_empty {
14371 let mut buf = Vec::new();
14372 loop {
14373 match reader.read_event_into(&mut buf)? {
14374 Event::Start(e) => {
14375 match e.local_name().as_ref() {
14376 b"cSld" => {
14377 f_common_slide_data =
14378 Some(Box::new(CommonSlideData::from_xml(reader, &e, false)?));
14379 #[cfg(feature = "extra-children")]
14380 {
14381 child_idx += 1;
14382 }
14383 }
14384 #[cfg(feature = "pml-styling")]
14385 b"clrMapOvr" => {
14386 f_clr_map_ovr = Some(Box::new(
14387 ooxml_dml::types::CTColorMappingOverride::from_xml(
14388 reader, &e, false,
14389 )?,
14390 ));
14391 #[cfg(feature = "extra-children")]
14392 {
14393 child_idx += 1;
14394 }
14395 }
14396 #[cfg(feature = "pml-transitions")]
14397 b"transition" => {
14398 f_transition =
14399 Some(Box::new(SlideTransition::from_xml(reader, &e, false)?));
14400 #[cfg(feature = "extra-children")]
14401 {
14402 child_idx += 1;
14403 }
14404 }
14405 #[cfg(feature = "pml-animations")]
14406 b"timing" => {
14407 f_timing =
14408 Some(Box::new(SlideTiming::from_xml(reader, &e, false)?));
14409 #[cfg(feature = "extra-children")]
14410 {
14411 child_idx += 1;
14412 }
14413 }
14414 #[cfg(feature = "pml-extensions")]
14415 b"extLst" => {
14416 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
14417 reader, &e, false,
14418 )?));
14419 #[cfg(feature = "extra-children")]
14420 {
14421 child_idx += 1;
14422 }
14423 }
14424 #[cfg(feature = "extra-children")]
14425 _ => {
14426 let elem = RawXmlElement::from_reader(reader, &e)?;
14428 extra_children.push(PositionedNode::new(
14429 child_idx,
14430 RawXmlNode::Element(elem),
14431 ));
14432 child_idx += 1;
14433 }
14434 #[cfg(not(feature = "extra-children"))]
14435 _ => {
14436 skip_element(reader)?;
14438 }
14439 }
14440 }
14441 Event::Empty(e) => {
14442 match e.local_name().as_ref() {
14443 b"cSld" => {
14444 f_common_slide_data =
14445 Some(Box::new(CommonSlideData::from_xml(reader, &e, true)?));
14446 #[cfg(feature = "extra-children")]
14447 {
14448 child_idx += 1;
14449 }
14450 }
14451 #[cfg(feature = "pml-styling")]
14452 b"clrMapOvr" => {
14453 f_clr_map_ovr = Some(Box::new(
14454 ooxml_dml::types::CTColorMappingOverride::from_xml(
14455 reader, &e, true,
14456 )?,
14457 ));
14458 #[cfg(feature = "extra-children")]
14459 {
14460 child_idx += 1;
14461 }
14462 }
14463 #[cfg(feature = "pml-transitions")]
14464 b"transition" => {
14465 f_transition =
14466 Some(Box::new(SlideTransition::from_xml(reader, &e, true)?));
14467 #[cfg(feature = "extra-children")]
14468 {
14469 child_idx += 1;
14470 }
14471 }
14472 #[cfg(feature = "pml-animations")]
14473 b"timing" => {
14474 f_timing = Some(Box::new(SlideTiming::from_xml(reader, &e, true)?));
14475 #[cfg(feature = "extra-children")]
14476 {
14477 child_idx += 1;
14478 }
14479 }
14480 #[cfg(feature = "pml-extensions")]
14481 b"extLst" => {
14482 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
14483 reader, &e, true,
14484 )?));
14485 #[cfg(feature = "extra-children")]
14486 {
14487 child_idx += 1;
14488 }
14489 }
14490 #[cfg(feature = "extra-children")]
14491 _ => {
14492 let elem = RawXmlElement::from_empty(&e);
14494 extra_children.push(PositionedNode::new(
14495 child_idx,
14496 RawXmlNode::Element(elem),
14497 ));
14498 child_idx += 1;
14499 }
14500 #[cfg(not(feature = "extra-children"))]
14501 _ => {}
14502 }
14503 }
14504 Event::End(_) => break,
14505 Event::Eof => break,
14506 _ => {}
14507 }
14508 buf.clear();
14509 }
14510 }
14511
14512 Ok(Self {
14513 #[cfg(feature = "pml-masters")]
14514 show_master_sp: f_show_master_sp,
14515 #[cfg(feature = "pml-masters")]
14516 show_master_ph_anim: f_show_master_ph_anim,
14517 show: f_show,
14518 common_slide_data: f_common_slide_data
14519 .ok_or_else(|| ParseError::MissingAttribute("cSld".to_string()))?,
14520 #[cfg(feature = "pml-styling")]
14521 clr_map_ovr: f_clr_map_ovr,
14522 #[cfg(feature = "pml-transitions")]
14523 transition: f_transition,
14524 #[cfg(feature = "pml-animations")]
14525 timing: f_timing,
14526 #[cfg(feature = "pml-extensions")]
14527 ext_lst: f_ext_lst,
14528 #[cfg(feature = "extra-attrs")]
14529 extra_attrs,
14530 #[cfg(feature = "extra-children")]
14531 extra_children,
14532 })
14533 }
14534}
14535
14536impl FromXml for SlideLayout {
14537 fn from_xml<R: BufRead>(
14538 reader: &mut Reader<R>,
14539 start_tag: &BytesStart,
14540 is_empty: bool,
14541 ) -> Result<Self, ParseError> {
14542 #[cfg(feature = "pml-masters")]
14543 let mut f_show_master_sp = None;
14544 #[cfg(feature = "pml-masters")]
14545 let mut f_show_master_ph_anim = None;
14546 #[cfg(feature = "pml-masters")]
14547 let mut f_matching_name = None;
14548 #[cfg(feature = "pml-masters")]
14549 let mut f_type = None;
14550 #[cfg(feature = "pml-masters")]
14551 let mut f_preserve = None;
14552 #[cfg(feature = "pml-masters")]
14553 let mut f_user_drawn = None;
14554 let mut f_common_slide_data: Option<Box<CommonSlideData>> = None;
14555 #[cfg(feature = "pml-styling")]
14556 let mut f_clr_map_ovr = None;
14557 #[cfg(feature = "pml-transitions")]
14558 let mut f_transition = None;
14559 #[cfg(feature = "pml-animations")]
14560 let mut f_timing = None;
14561 #[cfg(feature = "pml-masters")]
14562 let mut f_hf = None;
14563 #[cfg(feature = "pml-extensions")]
14564 let mut f_ext_lst = None;
14565 #[cfg(feature = "extra-attrs")]
14566 let mut extra_attrs = std::collections::HashMap::new();
14567 #[cfg(feature = "extra-children")]
14568 let mut extra_children = Vec::new();
14569 #[cfg(feature = "extra-children")]
14570 let mut child_idx: usize = 0;
14571
14572 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
14574 let val = String::from_utf8_lossy(&attr.value);
14575 match attr.key.local_name().as_ref() {
14576 #[cfg(feature = "pml-masters")]
14577 b"showMasterSp" => {
14578 f_show_master_sp = Some(val == "true" || val == "1");
14579 }
14580 #[cfg(feature = "pml-masters")]
14581 b"showMasterPhAnim" => {
14582 f_show_master_ph_anim = Some(val == "true" || val == "1");
14583 }
14584 #[cfg(feature = "pml-masters")]
14585 b"matchingName" => {
14586 f_matching_name = Some(val.into_owned());
14587 }
14588 #[cfg(feature = "pml-masters")]
14589 b"type" => {
14590 f_type = val.parse().ok();
14591 }
14592 #[cfg(feature = "pml-masters")]
14593 b"preserve" => {
14594 f_preserve = Some(val == "true" || val == "1");
14595 }
14596 #[cfg(feature = "pml-masters")]
14597 b"userDrawn" => {
14598 f_user_drawn = Some(val == "true" || val == "1");
14599 }
14600 #[cfg(feature = "extra-attrs")]
14601 unknown => {
14602 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
14603 extra_attrs.insert(key, val.into_owned());
14604 }
14605 #[cfg(not(feature = "extra-attrs"))]
14606 _ => {}
14607 }
14608 }
14609
14610 if !is_empty {
14612 let mut buf = Vec::new();
14613 loop {
14614 match reader.read_event_into(&mut buf)? {
14615 Event::Start(e) => {
14616 match e.local_name().as_ref() {
14617 b"cSld" => {
14618 f_common_slide_data =
14619 Some(Box::new(CommonSlideData::from_xml(reader, &e, false)?));
14620 #[cfg(feature = "extra-children")]
14621 {
14622 child_idx += 1;
14623 }
14624 }
14625 #[cfg(feature = "pml-styling")]
14626 b"clrMapOvr" => {
14627 f_clr_map_ovr = Some(Box::new(
14628 ooxml_dml::types::CTColorMappingOverride::from_xml(
14629 reader, &e, false,
14630 )?,
14631 ));
14632 #[cfg(feature = "extra-children")]
14633 {
14634 child_idx += 1;
14635 }
14636 }
14637 #[cfg(feature = "pml-transitions")]
14638 b"transition" => {
14639 f_transition =
14640 Some(Box::new(SlideTransition::from_xml(reader, &e, false)?));
14641 #[cfg(feature = "extra-children")]
14642 {
14643 child_idx += 1;
14644 }
14645 }
14646 #[cfg(feature = "pml-animations")]
14647 b"timing" => {
14648 f_timing =
14649 Some(Box::new(SlideTiming::from_xml(reader, &e, false)?));
14650 #[cfg(feature = "extra-children")]
14651 {
14652 child_idx += 1;
14653 }
14654 }
14655 #[cfg(feature = "pml-masters")]
14656 b"hf" => {
14657 f_hf = Some(Box::new(CTHeaderFooter::from_xml(reader, &e, false)?));
14658 #[cfg(feature = "extra-children")]
14659 {
14660 child_idx += 1;
14661 }
14662 }
14663 #[cfg(feature = "pml-extensions")]
14664 b"extLst" => {
14665 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
14666 reader, &e, false,
14667 )?));
14668 #[cfg(feature = "extra-children")]
14669 {
14670 child_idx += 1;
14671 }
14672 }
14673 #[cfg(feature = "extra-children")]
14674 _ => {
14675 let elem = RawXmlElement::from_reader(reader, &e)?;
14677 extra_children.push(PositionedNode::new(
14678 child_idx,
14679 RawXmlNode::Element(elem),
14680 ));
14681 child_idx += 1;
14682 }
14683 #[cfg(not(feature = "extra-children"))]
14684 _ => {
14685 skip_element(reader)?;
14687 }
14688 }
14689 }
14690 Event::Empty(e) => {
14691 match e.local_name().as_ref() {
14692 b"cSld" => {
14693 f_common_slide_data =
14694 Some(Box::new(CommonSlideData::from_xml(reader, &e, true)?));
14695 #[cfg(feature = "extra-children")]
14696 {
14697 child_idx += 1;
14698 }
14699 }
14700 #[cfg(feature = "pml-styling")]
14701 b"clrMapOvr" => {
14702 f_clr_map_ovr = Some(Box::new(
14703 ooxml_dml::types::CTColorMappingOverride::from_xml(
14704 reader, &e, true,
14705 )?,
14706 ));
14707 #[cfg(feature = "extra-children")]
14708 {
14709 child_idx += 1;
14710 }
14711 }
14712 #[cfg(feature = "pml-transitions")]
14713 b"transition" => {
14714 f_transition =
14715 Some(Box::new(SlideTransition::from_xml(reader, &e, true)?));
14716 #[cfg(feature = "extra-children")]
14717 {
14718 child_idx += 1;
14719 }
14720 }
14721 #[cfg(feature = "pml-animations")]
14722 b"timing" => {
14723 f_timing = Some(Box::new(SlideTiming::from_xml(reader, &e, true)?));
14724 #[cfg(feature = "extra-children")]
14725 {
14726 child_idx += 1;
14727 }
14728 }
14729 #[cfg(feature = "pml-masters")]
14730 b"hf" => {
14731 f_hf = Some(Box::new(CTHeaderFooter::from_xml(reader, &e, true)?));
14732 #[cfg(feature = "extra-children")]
14733 {
14734 child_idx += 1;
14735 }
14736 }
14737 #[cfg(feature = "pml-extensions")]
14738 b"extLst" => {
14739 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
14740 reader, &e, true,
14741 )?));
14742 #[cfg(feature = "extra-children")]
14743 {
14744 child_idx += 1;
14745 }
14746 }
14747 #[cfg(feature = "extra-children")]
14748 _ => {
14749 let elem = RawXmlElement::from_empty(&e);
14751 extra_children.push(PositionedNode::new(
14752 child_idx,
14753 RawXmlNode::Element(elem),
14754 ));
14755 child_idx += 1;
14756 }
14757 #[cfg(not(feature = "extra-children"))]
14758 _ => {}
14759 }
14760 }
14761 Event::End(_) => break,
14762 Event::Eof => break,
14763 _ => {}
14764 }
14765 buf.clear();
14766 }
14767 }
14768
14769 Ok(Self {
14770 #[cfg(feature = "pml-masters")]
14771 show_master_sp: f_show_master_sp,
14772 #[cfg(feature = "pml-masters")]
14773 show_master_ph_anim: f_show_master_ph_anim,
14774 #[cfg(feature = "pml-masters")]
14775 matching_name: f_matching_name,
14776 #[cfg(feature = "pml-masters")]
14777 r#type: f_type,
14778 #[cfg(feature = "pml-masters")]
14779 preserve: f_preserve,
14780 #[cfg(feature = "pml-masters")]
14781 user_drawn: f_user_drawn,
14782 common_slide_data: f_common_slide_data
14783 .ok_or_else(|| ParseError::MissingAttribute("cSld".to_string()))?,
14784 #[cfg(feature = "pml-styling")]
14785 clr_map_ovr: f_clr_map_ovr,
14786 #[cfg(feature = "pml-transitions")]
14787 transition: f_transition,
14788 #[cfg(feature = "pml-animations")]
14789 timing: f_timing,
14790 #[cfg(feature = "pml-masters")]
14791 hf: f_hf,
14792 #[cfg(feature = "pml-extensions")]
14793 ext_lst: f_ext_lst,
14794 #[cfg(feature = "extra-attrs")]
14795 extra_attrs,
14796 #[cfg(feature = "extra-children")]
14797 extra_children,
14798 })
14799 }
14800}
14801
14802impl FromXml for CTSlideMasterTextStyles {
14803 fn from_xml<R: BufRead>(
14804 reader: &mut Reader<R>,
14805 start_tag: &BytesStart,
14806 is_empty: bool,
14807 ) -> Result<Self, ParseError> {
14808 let mut f_title_style = None;
14809 let mut f_body_style = None;
14810 let mut f_other_style = None;
14811 let mut f_ext_lst = None;
14812 #[cfg(feature = "extra-children")]
14813 let mut extra_children = Vec::new();
14814 #[cfg(feature = "extra-children")]
14815 let mut child_idx: usize = 0;
14816
14817 if !is_empty {
14819 let mut buf = Vec::new();
14820 loop {
14821 match reader.read_event_into(&mut buf)? {
14822 Event::Start(e) => {
14823 match e.local_name().as_ref() {
14824 b"titleStyle" => {
14825 f_title_style = Some(Box::new(
14826 ooxml_dml::types::CTTextListStyle::from_xml(reader, &e, false)?,
14827 ));
14828 #[cfg(feature = "extra-children")]
14829 {
14830 child_idx += 1;
14831 }
14832 }
14833 b"bodyStyle" => {
14834 f_body_style = Some(Box::new(
14835 ooxml_dml::types::CTTextListStyle::from_xml(reader, &e, false)?,
14836 ));
14837 #[cfg(feature = "extra-children")]
14838 {
14839 child_idx += 1;
14840 }
14841 }
14842 b"otherStyle" => {
14843 f_other_style = Some(Box::new(
14844 ooxml_dml::types::CTTextListStyle::from_xml(reader, &e, false)?,
14845 ));
14846 #[cfg(feature = "extra-children")]
14847 {
14848 child_idx += 1;
14849 }
14850 }
14851 b"extLst" => {
14852 f_ext_lst =
14853 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
14854 #[cfg(feature = "extra-children")]
14855 {
14856 child_idx += 1;
14857 }
14858 }
14859 #[cfg(feature = "extra-children")]
14860 _ => {
14861 let elem = RawXmlElement::from_reader(reader, &e)?;
14863 extra_children.push(PositionedNode::new(
14864 child_idx,
14865 RawXmlNode::Element(elem),
14866 ));
14867 child_idx += 1;
14868 }
14869 #[cfg(not(feature = "extra-children"))]
14870 _ => {
14871 skip_element(reader)?;
14873 }
14874 }
14875 }
14876 Event::Empty(e) => {
14877 match e.local_name().as_ref() {
14878 b"titleStyle" => {
14879 f_title_style = Some(Box::new(
14880 ooxml_dml::types::CTTextListStyle::from_xml(reader, &e, true)?,
14881 ));
14882 #[cfg(feature = "extra-children")]
14883 {
14884 child_idx += 1;
14885 }
14886 }
14887 b"bodyStyle" => {
14888 f_body_style = Some(Box::new(
14889 ooxml_dml::types::CTTextListStyle::from_xml(reader, &e, true)?,
14890 ));
14891 #[cfg(feature = "extra-children")]
14892 {
14893 child_idx += 1;
14894 }
14895 }
14896 b"otherStyle" => {
14897 f_other_style = Some(Box::new(
14898 ooxml_dml::types::CTTextListStyle::from_xml(reader, &e, true)?,
14899 ));
14900 #[cfg(feature = "extra-children")]
14901 {
14902 child_idx += 1;
14903 }
14904 }
14905 b"extLst" => {
14906 f_ext_lst =
14907 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
14908 #[cfg(feature = "extra-children")]
14909 {
14910 child_idx += 1;
14911 }
14912 }
14913 #[cfg(feature = "extra-children")]
14914 _ => {
14915 let elem = RawXmlElement::from_empty(&e);
14917 extra_children.push(PositionedNode::new(
14918 child_idx,
14919 RawXmlNode::Element(elem),
14920 ));
14921 child_idx += 1;
14922 }
14923 #[cfg(not(feature = "extra-children"))]
14924 _ => {}
14925 }
14926 }
14927 Event::End(_) => break,
14928 Event::Eof => break,
14929 _ => {}
14930 }
14931 buf.clear();
14932 }
14933 }
14934
14935 Ok(Self {
14936 title_style: f_title_style,
14937 body_style: f_body_style,
14938 other_style: f_other_style,
14939 ext_lst: f_ext_lst,
14940 #[cfg(feature = "extra-children")]
14941 extra_children,
14942 })
14943 }
14944}
14945
14946impl FromXml for CTSlideLayoutIdListEntry {
14947 fn from_xml<R: BufRead>(
14948 reader: &mut Reader<R>,
14949 start_tag: &BytesStart,
14950 is_empty: bool,
14951 ) -> Result<Self, ParseError> {
14952 let mut f_id = None;
14953 let mut f_ext_lst = None;
14954 #[cfg(feature = "extra-attrs")]
14955 let mut extra_attrs = std::collections::HashMap::new();
14956 #[cfg(feature = "extra-children")]
14957 let mut extra_children = Vec::new();
14958 #[cfg(feature = "extra-children")]
14959 let mut child_idx: usize = 0;
14960
14961 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
14963 let val = String::from_utf8_lossy(&attr.value);
14964 match attr.key.local_name().as_ref() {
14965 b"id" => {
14966 f_id = val.parse().ok();
14967 }
14968 #[cfg(feature = "extra-attrs")]
14969 unknown => {
14970 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
14971 extra_attrs.insert(key, val.into_owned());
14972 }
14973 #[cfg(not(feature = "extra-attrs"))]
14974 _ => {}
14975 }
14976 }
14977
14978 if !is_empty {
14980 let mut buf = Vec::new();
14981 loop {
14982 match reader.read_event_into(&mut buf)? {
14983 Event::Start(e) => {
14984 match e.local_name().as_ref() {
14985 b"extLst" => {
14986 f_ext_lst =
14987 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
14988 #[cfg(feature = "extra-children")]
14989 {
14990 child_idx += 1;
14991 }
14992 }
14993 #[cfg(feature = "extra-children")]
14994 _ => {
14995 let elem = RawXmlElement::from_reader(reader, &e)?;
14997 extra_children.push(PositionedNode::new(
14998 child_idx,
14999 RawXmlNode::Element(elem),
15000 ));
15001 child_idx += 1;
15002 }
15003 #[cfg(not(feature = "extra-children"))]
15004 _ => {
15005 skip_element(reader)?;
15007 }
15008 }
15009 }
15010 Event::Empty(e) => {
15011 match e.local_name().as_ref() {
15012 b"extLst" => {
15013 f_ext_lst =
15014 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
15015 #[cfg(feature = "extra-children")]
15016 {
15017 child_idx += 1;
15018 }
15019 }
15020 #[cfg(feature = "extra-children")]
15021 _ => {
15022 let elem = RawXmlElement::from_empty(&e);
15024 extra_children.push(PositionedNode::new(
15025 child_idx,
15026 RawXmlNode::Element(elem),
15027 ));
15028 child_idx += 1;
15029 }
15030 #[cfg(not(feature = "extra-children"))]
15031 _ => {}
15032 }
15033 }
15034 Event::End(_) => break,
15035 Event::Eof => break,
15036 _ => {}
15037 }
15038 buf.clear();
15039 }
15040 }
15041
15042 Ok(Self {
15043 id: f_id,
15044 ext_lst: f_ext_lst,
15045 #[cfg(feature = "extra-attrs")]
15046 extra_attrs,
15047 #[cfg(feature = "extra-children")]
15048 extra_children,
15049 })
15050 }
15051}
15052
15053impl FromXml for CTSlideLayoutIdList {
15054 fn from_xml<R: BufRead>(
15055 reader: &mut Reader<R>,
15056 start_tag: &BytesStart,
15057 is_empty: bool,
15058 ) -> Result<Self, ParseError> {
15059 let mut f_sld_layout_id = Vec::new();
15060 #[cfg(feature = "extra-children")]
15061 let mut extra_children = Vec::new();
15062 #[cfg(feature = "extra-children")]
15063 let mut child_idx: usize = 0;
15064
15065 if !is_empty {
15067 let mut buf = Vec::new();
15068 loop {
15069 match reader.read_event_into(&mut buf)? {
15070 Event::Start(e) => {
15071 match e.local_name().as_ref() {
15072 b"sldLayoutId" => {
15073 f_sld_layout_id
15074 .push(CTSlideLayoutIdListEntry::from_xml(reader, &e, false)?);
15075 #[cfg(feature = "extra-children")]
15076 {
15077 child_idx += 1;
15078 }
15079 }
15080 #[cfg(feature = "extra-children")]
15081 _ => {
15082 let elem = RawXmlElement::from_reader(reader, &e)?;
15084 extra_children.push(PositionedNode::new(
15085 child_idx,
15086 RawXmlNode::Element(elem),
15087 ));
15088 child_idx += 1;
15089 }
15090 #[cfg(not(feature = "extra-children"))]
15091 _ => {
15092 skip_element(reader)?;
15094 }
15095 }
15096 }
15097 Event::Empty(e) => {
15098 match e.local_name().as_ref() {
15099 b"sldLayoutId" => {
15100 f_sld_layout_id
15101 .push(CTSlideLayoutIdListEntry::from_xml(reader, &e, true)?);
15102 #[cfg(feature = "extra-children")]
15103 {
15104 child_idx += 1;
15105 }
15106 }
15107 #[cfg(feature = "extra-children")]
15108 _ => {
15109 let elem = RawXmlElement::from_empty(&e);
15111 extra_children.push(PositionedNode::new(
15112 child_idx,
15113 RawXmlNode::Element(elem),
15114 ));
15115 child_idx += 1;
15116 }
15117 #[cfg(not(feature = "extra-children"))]
15118 _ => {}
15119 }
15120 }
15121 Event::End(_) => break,
15122 Event::Eof => break,
15123 _ => {}
15124 }
15125 buf.clear();
15126 }
15127 }
15128
15129 Ok(Self {
15130 sld_layout_id: f_sld_layout_id,
15131 #[cfg(feature = "extra-children")]
15132 extra_children,
15133 })
15134 }
15135}
15136
15137impl FromXml for SlideMaster {
15138 fn from_xml<R: BufRead>(
15139 reader: &mut Reader<R>,
15140 start_tag: &BytesStart,
15141 is_empty: bool,
15142 ) -> Result<Self, ParseError> {
15143 #[cfg(feature = "pml-masters")]
15144 let mut f_preserve = None;
15145 let mut f_common_slide_data: Option<Box<CommonSlideData>> = None;
15146 let mut f_clr_map: Option<Box<ooxml_dml::types::CTColorMapping>> = None;
15147 #[cfg(feature = "pml-masters")]
15148 let mut f_sld_layout_id_lst = None;
15149 #[cfg(feature = "pml-transitions")]
15150 let mut f_transition = None;
15151 #[cfg(feature = "pml-animations")]
15152 let mut f_timing = None;
15153 #[cfg(feature = "pml-masters")]
15154 let mut f_hf = None;
15155 #[cfg(feature = "pml-styling")]
15156 let mut f_tx_styles = None;
15157 #[cfg(feature = "pml-extensions")]
15158 let mut f_ext_lst = None;
15159 #[cfg(feature = "extra-attrs")]
15160 let mut extra_attrs = std::collections::HashMap::new();
15161 #[cfg(feature = "extra-children")]
15162 let mut extra_children = Vec::new();
15163 #[cfg(feature = "extra-children")]
15164 let mut child_idx: usize = 0;
15165
15166 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
15168 let val = String::from_utf8_lossy(&attr.value);
15169 match attr.key.local_name().as_ref() {
15170 #[cfg(feature = "pml-masters")]
15171 b"preserve" => {
15172 f_preserve = Some(val == "true" || val == "1");
15173 }
15174 #[cfg(feature = "extra-attrs")]
15175 unknown => {
15176 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
15177 extra_attrs.insert(key, val.into_owned());
15178 }
15179 #[cfg(not(feature = "extra-attrs"))]
15180 _ => {}
15181 }
15182 }
15183
15184 if !is_empty {
15186 let mut buf = Vec::new();
15187 loop {
15188 match reader.read_event_into(&mut buf)? {
15189 Event::Start(e) => {
15190 match e.local_name().as_ref() {
15191 b"cSld" => {
15192 f_common_slide_data =
15193 Some(Box::new(CommonSlideData::from_xml(reader, &e, false)?));
15194 #[cfg(feature = "extra-children")]
15195 {
15196 child_idx += 1;
15197 }
15198 }
15199 b"clrMap" => {
15200 f_clr_map = Some(Box::new(
15201 ooxml_dml::types::CTColorMapping::from_xml(reader, &e, false)?,
15202 ));
15203 #[cfg(feature = "extra-children")]
15204 {
15205 child_idx += 1;
15206 }
15207 }
15208 #[cfg(feature = "pml-masters")]
15209 b"sldLayoutIdLst" => {
15210 f_sld_layout_id_lst = Some(Box::new(
15211 CTSlideLayoutIdList::from_xml(reader, &e, false)?,
15212 ));
15213 #[cfg(feature = "extra-children")]
15214 {
15215 child_idx += 1;
15216 }
15217 }
15218 #[cfg(feature = "pml-transitions")]
15219 b"transition" => {
15220 f_transition =
15221 Some(Box::new(SlideTransition::from_xml(reader, &e, false)?));
15222 #[cfg(feature = "extra-children")]
15223 {
15224 child_idx += 1;
15225 }
15226 }
15227 #[cfg(feature = "pml-animations")]
15228 b"timing" => {
15229 f_timing =
15230 Some(Box::new(SlideTiming::from_xml(reader, &e, false)?));
15231 #[cfg(feature = "extra-children")]
15232 {
15233 child_idx += 1;
15234 }
15235 }
15236 #[cfg(feature = "pml-masters")]
15237 b"hf" => {
15238 f_hf = Some(Box::new(CTHeaderFooter::from_xml(reader, &e, false)?));
15239 #[cfg(feature = "extra-children")]
15240 {
15241 child_idx += 1;
15242 }
15243 }
15244 #[cfg(feature = "pml-styling")]
15245 b"txStyles" => {
15246 f_tx_styles = Some(Box::new(CTSlideMasterTextStyles::from_xml(
15247 reader, &e, false,
15248 )?));
15249 #[cfg(feature = "extra-children")]
15250 {
15251 child_idx += 1;
15252 }
15253 }
15254 #[cfg(feature = "pml-extensions")]
15255 b"extLst" => {
15256 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
15257 reader, &e, false,
15258 )?));
15259 #[cfg(feature = "extra-children")]
15260 {
15261 child_idx += 1;
15262 }
15263 }
15264 #[cfg(feature = "extra-children")]
15265 _ => {
15266 let elem = RawXmlElement::from_reader(reader, &e)?;
15268 extra_children.push(PositionedNode::new(
15269 child_idx,
15270 RawXmlNode::Element(elem),
15271 ));
15272 child_idx += 1;
15273 }
15274 #[cfg(not(feature = "extra-children"))]
15275 _ => {
15276 skip_element(reader)?;
15278 }
15279 }
15280 }
15281 Event::Empty(e) => {
15282 match e.local_name().as_ref() {
15283 b"cSld" => {
15284 f_common_slide_data =
15285 Some(Box::new(CommonSlideData::from_xml(reader, &e, true)?));
15286 #[cfg(feature = "extra-children")]
15287 {
15288 child_idx += 1;
15289 }
15290 }
15291 b"clrMap" => {
15292 f_clr_map = Some(Box::new(
15293 ooxml_dml::types::CTColorMapping::from_xml(reader, &e, true)?,
15294 ));
15295 #[cfg(feature = "extra-children")]
15296 {
15297 child_idx += 1;
15298 }
15299 }
15300 #[cfg(feature = "pml-masters")]
15301 b"sldLayoutIdLst" => {
15302 f_sld_layout_id_lst = Some(Box::new(
15303 CTSlideLayoutIdList::from_xml(reader, &e, true)?,
15304 ));
15305 #[cfg(feature = "extra-children")]
15306 {
15307 child_idx += 1;
15308 }
15309 }
15310 #[cfg(feature = "pml-transitions")]
15311 b"transition" => {
15312 f_transition =
15313 Some(Box::new(SlideTransition::from_xml(reader, &e, true)?));
15314 #[cfg(feature = "extra-children")]
15315 {
15316 child_idx += 1;
15317 }
15318 }
15319 #[cfg(feature = "pml-animations")]
15320 b"timing" => {
15321 f_timing = Some(Box::new(SlideTiming::from_xml(reader, &e, true)?));
15322 #[cfg(feature = "extra-children")]
15323 {
15324 child_idx += 1;
15325 }
15326 }
15327 #[cfg(feature = "pml-masters")]
15328 b"hf" => {
15329 f_hf = Some(Box::new(CTHeaderFooter::from_xml(reader, &e, true)?));
15330 #[cfg(feature = "extra-children")]
15331 {
15332 child_idx += 1;
15333 }
15334 }
15335 #[cfg(feature = "pml-styling")]
15336 b"txStyles" => {
15337 f_tx_styles = Some(Box::new(CTSlideMasterTextStyles::from_xml(
15338 reader, &e, true,
15339 )?));
15340 #[cfg(feature = "extra-children")]
15341 {
15342 child_idx += 1;
15343 }
15344 }
15345 #[cfg(feature = "pml-extensions")]
15346 b"extLst" => {
15347 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
15348 reader, &e, true,
15349 )?));
15350 #[cfg(feature = "extra-children")]
15351 {
15352 child_idx += 1;
15353 }
15354 }
15355 #[cfg(feature = "extra-children")]
15356 _ => {
15357 let elem = RawXmlElement::from_empty(&e);
15359 extra_children.push(PositionedNode::new(
15360 child_idx,
15361 RawXmlNode::Element(elem),
15362 ));
15363 child_idx += 1;
15364 }
15365 #[cfg(not(feature = "extra-children"))]
15366 _ => {}
15367 }
15368 }
15369 Event::End(_) => break,
15370 Event::Eof => break,
15371 _ => {}
15372 }
15373 buf.clear();
15374 }
15375 }
15376
15377 Ok(Self {
15378 #[cfg(feature = "pml-masters")]
15379 preserve: f_preserve,
15380 common_slide_data: f_common_slide_data
15381 .ok_or_else(|| ParseError::MissingAttribute("cSld".to_string()))?,
15382 clr_map: f_clr_map.ok_or_else(|| ParseError::MissingAttribute("clrMap".to_string()))?,
15383 #[cfg(feature = "pml-masters")]
15384 sld_layout_id_lst: f_sld_layout_id_lst,
15385 #[cfg(feature = "pml-transitions")]
15386 transition: f_transition,
15387 #[cfg(feature = "pml-animations")]
15388 timing: f_timing,
15389 #[cfg(feature = "pml-masters")]
15390 hf: f_hf,
15391 #[cfg(feature = "pml-styling")]
15392 tx_styles: f_tx_styles,
15393 #[cfg(feature = "pml-extensions")]
15394 ext_lst: f_ext_lst,
15395 #[cfg(feature = "extra-attrs")]
15396 extra_attrs,
15397 #[cfg(feature = "extra-children")]
15398 extra_children,
15399 })
15400 }
15401}
15402
15403impl FromXml for HandoutMaster {
15404 fn from_xml<R: BufRead>(
15405 reader: &mut Reader<R>,
15406 start_tag: &BytesStart,
15407 is_empty: bool,
15408 ) -> Result<Self, ParseError> {
15409 let mut f_common_slide_data: Option<Box<CommonSlideData>> = None;
15410 let mut f_clr_map: Option<Box<ooxml_dml::types::CTColorMapping>> = None;
15411 #[cfg(feature = "pml-masters")]
15412 let mut f_hf = None;
15413 #[cfg(feature = "pml-extensions")]
15414 let mut f_ext_lst = None;
15415 #[cfg(feature = "extra-children")]
15416 let mut extra_children = Vec::new();
15417 #[cfg(feature = "extra-children")]
15418 let mut child_idx: usize = 0;
15419
15420 if !is_empty {
15422 let mut buf = Vec::new();
15423 loop {
15424 match reader.read_event_into(&mut buf)? {
15425 Event::Start(e) => {
15426 match e.local_name().as_ref() {
15427 b"cSld" => {
15428 f_common_slide_data =
15429 Some(Box::new(CommonSlideData::from_xml(reader, &e, false)?));
15430 #[cfg(feature = "extra-children")]
15431 {
15432 child_idx += 1;
15433 }
15434 }
15435 b"clrMap" => {
15436 f_clr_map = Some(Box::new(
15437 ooxml_dml::types::CTColorMapping::from_xml(reader, &e, false)?,
15438 ));
15439 #[cfg(feature = "extra-children")]
15440 {
15441 child_idx += 1;
15442 }
15443 }
15444 #[cfg(feature = "pml-masters")]
15445 b"hf" => {
15446 f_hf = Some(Box::new(CTHeaderFooter::from_xml(reader, &e, false)?));
15447 #[cfg(feature = "extra-children")]
15448 {
15449 child_idx += 1;
15450 }
15451 }
15452 #[cfg(feature = "pml-extensions")]
15453 b"extLst" => {
15454 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
15455 reader, &e, false,
15456 )?));
15457 #[cfg(feature = "extra-children")]
15458 {
15459 child_idx += 1;
15460 }
15461 }
15462 #[cfg(feature = "extra-children")]
15463 _ => {
15464 let elem = RawXmlElement::from_reader(reader, &e)?;
15466 extra_children.push(PositionedNode::new(
15467 child_idx,
15468 RawXmlNode::Element(elem),
15469 ));
15470 child_idx += 1;
15471 }
15472 #[cfg(not(feature = "extra-children"))]
15473 _ => {
15474 skip_element(reader)?;
15476 }
15477 }
15478 }
15479 Event::Empty(e) => {
15480 match e.local_name().as_ref() {
15481 b"cSld" => {
15482 f_common_slide_data =
15483 Some(Box::new(CommonSlideData::from_xml(reader, &e, true)?));
15484 #[cfg(feature = "extra-children")]
15485 {
15486 child_idx += 1;
15487 }
15488 }
15489 b"clrMap" => {
15490 f_clr_map = Some(Box::new(
15491 ooxml_dml::types::CTColorMapping::from_xml(reader, &e, true)?,
15492 ));
15493 #[cfg(feature = "extra-children")]
15494 {
15495 child_idx += 1;
15496 }
15497 }
15498 #[cfg(feature = "pml-masters")]
15499 b"hf" => {
15500 f_hf = Some(Box::new(CTHeaderFooter::from_xml(reader, &e, true)?));
15501 #[cfg(feature = "extra-children")]
15502 {
15503 child_idx += 1;
15504 }
15505 }
15506 #[cfg(feature = "pml-extensions")]
15507 b"extLst" => {
15508 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
15509 reader, &e, true,
15510 )?));
15511 #[cfg(feature = "extra-children")]
15512 {
15513 child_idx += 1;
15514 }
15515 }
15516 #[cfg(feature = "extra-children")]
15517 _ => {
15518 let elem = RawXmlElement::from_empty(&e);
15520 extra_children.push(PositionedNode::new(
15521 child_idx,
15522 RawXmlNode::Element(elem),
15523 ));
15524 child_idx += 1;
15525 }
15526 #[cfg(not(feature = "extra-children"))]
15527 _ => {}
15528 }
15529 }
15530 Event::End(_) => break,
15531 Event::Eof => break,
15532 _ => {}
15533 }
15534 buf.clear();
15535 }
15536 }
15537
15538 Ok(Self {
15539 common_slide_data: f_common_slide_data
15540 .ok_or_else(|| ParseError::MissingAttribute("cSld".to_string()))?,
15541 clr_map: f_clr_map.ok_or_else(|| ParseError::MissingAttribute("clrMap".to_string()))?,
15542 #[cfg(feature = "pml-masters")]
15543 hf: f_hf,
15544 #[cfg(feature = "pml-extensions")]
15545 ext_lst: f_ext_lst,
15546 #[cfg(feature = "extra-children")]
15547 extra_children,
15548 })
15549 }
15550}
15551
15552impl FromXml for NotesMaster {
15553 fn from_xml<R: BufRead>(
15554 reader: &mut Reader<R>,
15555 start_tag: &BytesStart,
15556 is_empty: bool,
15557 ) -> Result<Self, ParseError> {
15558 let mut f_common_slide_data: Option<Box<CommonSlideData>> = None;
15559 let mut f_clr_map: Option<Box<ooxml_dml::types::CTColorMapping>> = None;
15560 #[cfg(feature = "pml-notes")]
15561 let mut f_hf = None;
15562 #[cfg(feature = "pml-styling")]
15563 let mut f_notes_style = None;
15564 #[cfg(feature = "pml-extensions")]
15565 let mut f_ext_lst = None;
15566 #[cfg(feature = "extra-children")]
15567 let mut extra_children = Vec::new();
15568 #[cfg(feature = "extra-children")]
15569 let mut child_idx: usize = 0;
15570
15571 if !is_empty {
15573 let mut buf = Vec::new();
15574 loop {
15575 match reader.read_event_into(&mut buf)? {
15576 Event::Start(e) => {
15577 match e.local_name().as_ref() {
15578 b"cSld" => {
15579 f_common_slide_data =
15580 Some(Box::new(CommonSlideData::from_xml(reader, &e, false)?));
15581 #[cfg(feature = "extra-children")]
15582 {
15583 child_idx += 1;
15584 }
15585 }
15586 b"clrMap" => {
15587 f_clr_map = Some(Box::new(
15588 ooxml_dml::types::CTColorMapping::from_xml(reader, &e, false)?,
15589 ));
15590 #[cfg(feature = "extra-children")]
15591 {
15592 child_idx += 1;
15593 }
15594 }
15595 #[cfg(feature = "pml-notes")]
15596 b"hf" => {
15597 f_hf = Some(Box::new(CTHeaderFooter::from_xml(reader, &e, false)?));
15598 #[cfg(feature = "extra-children")]
15599 {
15600 child_idx += 1;
15601 }
15602 }
15603 #[cfg(feature = "pml-styling")]
15604 b"notesStyle" => {
15605 f_notes_style = Some(Box::new(
15606 ooxml_dml::types::CTTextListStyle::from_xml(reader, &e, false)?,
15607 ));
15608 #[cfg(feature = "extra-children")]
15609 {
15610 child_idx += 1;
15611 }
15612 }
15613 #[cfg(feature = "pml-extensions")]
15614 b"extLst" => {
15615 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
15616 reader, &e, false,
15617 )?));
15618 #[cfg(feature = "extra-children")]
15619 {
15620 child_idx += 1;
15621 }
15622 }
15623 #[cfg(feature = "extra-children")]
15624 _ => {
15625 let elem = RawXmlElement::from_reader(reader, &e)?;
15627 extra_children.push(PositionedNode::new(
15628 child_idx,
15629 RawXmlNode::Element(elem),
15630 ));
15631 child_idx += 1;
15632 }
15633 #[cfg(not(feature = "extra-children"))]
15634 _ => {
15635 skip_element(reader)?;
15637 }
15638 }
15639 }
15640 Event::Empty(e) => {
15641 match e.local_name().as_ref() {
15642 b"cSld" => {
15643 f_common_slide_data =
15644 Some(Box::new(CommonSlideData::from_xml(reader, &e, true)?));
15645 #[cfg(feature = "extra-children")]
15646 {
15647 child_idx += 1;
15648 }
15649 }
15650 b"clrMap" => {
15651 f_clr_map = Some(Box::new(
15652 ooxml_dml::types::CTColorMapping::from_xml(reader, &e, true)?,
15653 ));
15654 #[cfg(feature = "extra-children")]
15655 {
15656 child_idx += 1;
15657 }
15658 }
15659 #[cfg(feature = "pml-notes")]
15660 b"hf" => {
15661 f_hf = Some(Box::new(CTHeaderFooter::from_xml(reader, &e, true)?));
15662 #[cfg(feature = "extra-children")]
15663 {
15664 child_idx += 1;
15665 }
15666 }
15667 #[cfg(feature = "pml-styling")]
15668 b"notesStyle" => {
15669 f_notes_style = Some(Box::new(
15670 ooxml_dml::types::CTTextListStyle::from_xml(reader, &e, true)?,
15671 ));
15672 #[cfg(feature = "extra-children")]
15673 {
15674 child_idx += 1;
15675 }
15676 }
15677 #[cfg(feature = "pml-extensions")]
15678 b"extLst" => {
15679 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
15680 reader, &e, true,
15681 )?));
15682 #[cfg(feature = "extra-children")]
15683 {
15684 child_idx += 1;
15685 }
15686 }
15687 #[cfg(feature = "extra-children")]
15688 _ => {
15689 let elem = RawXmlElement::from_empty(&e);
15691 extra_children.push(PositionedNode::new(
15692 child_idx,
15693 RawXmlNode::Element(elem),
15694 ));
15695 child_idx += 1;
15696 }
15697 #[cfg(not(feature = "extra-children"))]
15698 _ => {}
15699 }
15700 }
15701 Event::End(_) => break,
15702 Event::Eof => break,
15703 _ => {}
15704 }
15705 buf.clear();
15706 }
15707 }
15708
15709 Ok(Self {
15710 common_slide_data: f_common_slide_data
15711 .ok_or_else(|| ParseError::MissingAttribute("cSld".to_string()))?,
15712 clr_map: f_clr_map.ok_or_else(|| ParseError::MissingAttribute("clrMap".to_string()))?,
15713 #[cfg(feature = "pml-notes")]
15714 hf: f_hf,
15715 #[cfg(feature = "pml-styling")]
15716 notes_style: f_notes_style,
15717 #[cfg(feature = "pml-extensions")]
15718 ext_lst: f_ext_lst,
15719 #[cfg(feature = "extra-children")]
15720 extra_children,
15721 })
15722 }
15723}
15724
15725impl FromXml for NotesSlide {
15726 fn from_xml<R: BufRead>(
15727 reader: &mut Reader<R>,
15728 start_tag: &BytesStart,
15729 is_empty: bool,
15730 ) -> Result<Self, ParseError> {
15731 #[cfg(feature = "pml-notes")]
15732 let mut f_show_master_sp = None;
15733 #[cfg(feature = "pml-notes")]
15734 let mut f_show_master_ph_anim = None;
15735 let mut f_common_slide_data: Option<Box<CommonSlideData>> = None;
15736 #[cfg(feature = "pml-styling")]
15737 let mut f_clr_map_ovr = None;
15738 #[cfg(feature = "pml-extensions")]
15739 let mut f_ext_lst = None;
15740 #[cfg(feature = "extra-attrs")]
15741 let mut extra_attrs = std::collections::HashMap::new();
15742 #[cfg(feature = "extra-children")]
15743 let mut extra_children = Vec::new();
15744 #[cfg(feature = "extra-children")]
15745 let mut child_idx: usize = 0;
15746
15747 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
15749 let val = String::from_utf8_lossy(&attr.value);
15750 match attr.key.local_name().as_ref() {
15751 #[cfg(feature = "pml-notes")]
15752 b"showMasterSp" => {
15753 f_show_master_sp = Some(val == "true" || val == "1");
15754 }
15755 #[cfg(feature = "pml-notes")]
15756 b"showMasterPhAnim" => {
15757 f_show_master_ph_anim = Some(val == "true" || val == "1");
15758 }
15759 #[cfg(feature = "extra-attrs")]
15760 unknown => {
15761 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
15762 extra_attrs.insert(key, val.into_owned());
15763 }
15764 #[cfg(not(feature = "extra-attrs"))]
15765 _ => {}
15766 }
15767 }
15768
15769 if !is_empty {
15771 let mut buf = Vec::new();
15772 loop {
15773 match reader.read_event_into(&mut buf)? {
15774 Event::Start(e) => {
15775 match e.local_name().as_ref() {
15776 b"cSld" => {
15777 f_common_slide_data =
15778 Some(Box::new(CommonSlideData::from_xml(reader, &e, false)?));
15779 #[cfg(feature = "extra-children")]
15780 {
15781 child_idx += 1;
15782 }
15783 }
15784 #[cfg(feature = "pml-styling")]
15785 b"clrMapOvr" => {
15786 f_clr_map_ovr = Some(Box::new(
15787 ooxml_dml::types::CTColorMappingOverride::from_xml(
15788 reader, &e, false,
15789 )?,
15790 ));
15791 #[cfg(feature = "extra-children")]
15792 {
15793 child_idx += 1;
15794 }
15795 }
15796 #[cfg(feature = "pml-extensions")]
15797 b"extLst" => {
15798 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
15799 reader, &e, false,
15800 )?));
15801 #[cfg(feature = "extra-children")]
15802 {
15803 child_idx += 1;
15804 }
15805 }
15806 #[cfg(feature = "extra-children")]
15807 _ => {
15808 let elem = RawXmlElement::from_reader(reader, &e)?;
15810 extra_children.push(PositionedNode::new(
15811 child_idx,
15812 RawXmlNode::Element(elem),
15813 ));
15814 child_idx += 1;
15815 }
15816 #[cfg(not(feature = "extra-children"))]
15817 _ => {
15818 skip_element(reader)?;
15820 }
15821 }
15822 }
15823 Event::Empty(e) => {
15824 match e.local_name().as_ref() {
15825 b"cSld" => {
15826 f_common_slide_data =
15827 Some(Box::new(CommonSlideData::from_xml(reader, &e, true)?));
15828 #[cfg(feature = "extra-children")]
15829 {
15830 child_idx += 1;
15831 }
15832 }
15833 #[cfg(feature = "pml-styling")]
15834 b"clrMapOvr" => {
15835 f_clr_map_ovr = Some(Box::new(
15836 ooxml_dml::types::CTColorMappingOverride::from_xml(
15837 reader, &e, true,
15838 )?,
15839 ));
15840 #[cfg(feature = "extra-children")]
15841 {
15842 child_idx += 1;
15843 }
15844 }
15845 #[cfg(feature = "pml-extensions")]
15846 b"extLst" => {
15847 f_ext_lst = Some(Box::new(CTExtensionListModify::from_xml(
15848 reader, &e, true,
15849 )?));
15850 #[cfg(feature = "extra-children")]
15851 {
15852 child_idx += 1;
15853 }
15854 }
15855 #[cfg(feature = "extra-children")]
15856 _ => {
15857 let elem = RawXmlElement::from_empty(&e);
15859 extra_children.push(PositionedNode::new(
15860 child_idx,
15861 RawXmlNode::Element(elem),
15862 ));
15863 child_idx += 1;
15864 }
15865 #[cfg(not(feature = "extra-children"))]
15866 _ => {}
15867 }
15868 }
15869 Event::End(_) => break,
15870 Event::Eof => break,
15871 _ => {}
15872 }
15873 buf.clear();
15874 }
15875 }
15876
15877 Ok(Self {
15878 #[cfg(feature = "pml-notes")]
15879 show_master_sp: f_show_master_sp,
15880 #[cfg(feature = "pml-notes")]
15881 show_master_ph_anim: f_show_master_ph_anim,
15882 common_slide_data: f_common_slide_data
15883 .ok_or_else(|| ParseError::MissingAttribute("cSld".to_string()))?,
15884 #[cfg(feature = "pml-styling")]
15885 clr_map_ovr: f_clr_map_ovr,
15886 #[cfg(feature = "pml-extensions")]
15887 ext_lst: f_ext_lst,
15888 #[cfg(feature = "extra-attrs")]
15889 extra_attrs,
15890 #[cfg(feature = "extra-children")]
15891 extra_children,
15892 })
15893 }
15894}
15895
15896impl FromXml for CTSlideSyncProperties {
15897 fn from_xml<R: BufRead>(
15898 reader: &mut Reader<R>,
15899 start_tag: &BytesStart,
15900 is_empty: bool,
15901 ) -> Result<Self, ParseError> {
15902 let mut f_server_sld_id: Option<String> = None;
15903 let mut f_server_sld_modified_time: Option<String> = None;
15904 let mut f_client_inserted_time: Option<String> = None;
15905 let mut f_ext_lst = None;
15906 #[cfg(feature = "extra-attrs")]
15907 let mut extra_attrs = std::collections::HashMap::new();
15908 #[cfg(feature = "extra-children")]
15909 let mut extra_children = Vec::new();
15910 #[cfg(feature = "extra-children")]
15911 let mut child_idx: usize = 0;
15912
15913 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
15915 let val = String::from_utf8_lossy(&attr.value);
15916 match attr.key.local_name().as_ref() {
15917 b"serverSldId" => {
15918 f_server_sld_id = Some(val.into_owned());
15919 }
15920 b"serverSldModifiedTime" => {
15921 f_server_sld_modified_time = Some(val.into_owned());
15922 }
15923 b"clientInsertedTime" => {
15924 f_client_inserted_time = Some(val.into_owned());
15925 }
15926 #[cfg(feature = "extra-attrs")]
15927 unknown => {
15928 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
15929 extra_attrs.insert(key, val.into_owned());
15930 }
15931 #[cfg(not(feature = "extra-attrs"))]
15932 _ => {}
15933 }
15934 }
15935
15936 if !is_empty {
15938 let mut buf = Vec::new();
15939 loop {
15940 match reader.read_event_into(&mut buf)? {
15941 Event::Start(e) => {
15942 match e.local_name().as_ref() {
15943 b"extLst" => {
15944 f_ext_lst =
15945 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
15946 #[cfg(feature = "extra-children")]
15947 {
15948 child_idx += 1;
15949 }
15950 }
15951 #[cfg(feature = "extra-children")]
15952 _ => {
15953 let elem = RawXmlElement::from_reader(reader, &e)?;
15955 extra_children.push(PositionedNode::new(
15956 child_idx,
15957 RawXmlNode::Element(elem),
15958 ));
15959 child_idx += 1;
15960 }
15961 #[cfg(not(feature = "extra-children"))]
15962 _ => {
15963 skip_element(reader)?;
15965 }
15966 }
15967 }
15968 Event::Empty(e) => {
15969 match e.local_name().as_ref() {
15970 b"extLst" => {
15971 f_ext_lst =
15972 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
15973 #[cfg(feature = "extra-children")]
15974 {
15975 child_idx += 1;
15976 }
15977 }
15978 #[cfg(feature = "extra-children")]
15979 _ => {
15980 let elem = RawXmlElement::from_empty(&e);
15982 extra_children.push(PositionedNode::new(
15983 child_idx,
15984 RawXmlNode::Element(elem),
15985 ));
15986 child_idx += 1;
15987 }
15988 #[cfg(not(feature = "extra-children"))]
15989 _ => {}
15990 }
15991 }
15992 Event::End(_) => break,
15993 Event::Eof => break,
15994 _ => {}
15995 }
15996 buf.clear();
15997 }
15998 }
15999
16000 Ok(Self {
16001 server_sld_id: f_server_sld_id
16002 .ok_or_else(|| ParseError::MissingAttribute("serverSldId".to_string()))?,
16003 server_sld_modified_time: f_server_sld_modified_time
16004 .ok_or_else(|| ParseError::MissingAttribute("serverSldModifiedTime".to_string()))?,
16005 client_inserted_time: f_client_inserted_time
16006 .ok_or_else(|| ParseError::MissingAttribute("clientInsertedTime".to_string()))?,
16007 ext_lst: f_ext_lst,
16008 #[cfg(feature = "extra-attrs")]
16009 extra_attrs,
16010 #[cfg(feature = "extra-children")]
16011 extra_children,
16012 })
16013 }
16014}
16015
16016impl FromXml for CTStringTag {
16017 fn from_xml<R: BufRead>(
16018 reader: &mut Reader<R>,
16019 start_tag: &BytesStart,
16020 is_empty: bool,
16021 ) -> Result<Self, ParseError> {
16022 let mut f_name: Option<String> = None;
16023 let mut f_value: Option<String> = None;
16024 #[cfg(feature = "extra-attrs")]
16025 let mut extra_attrs = std::collections::HashMap::new();
16026
16027 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
16029 let val = String::from_utf8_lossy(&attr.value);
16030 match attr.key.local_name().as_ref() {
16031 b"name" => {
16032 f_name = Some(val.into_owned());
16033 }
16034 b"val" => {
16035 f_value = Some(val.into_owned());
16036 }
16037 #[cfg(feature = "extra-attrs")]
16038 unknown => {
16039 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
16040 extra_attrs.insert(key, val.into_owned());
16041 }
16042 #[cfg(not(feature = "extra-attrs"))]
16043 _ => {}
16044 }
16045 }
16046
16047 if !is_empty {
16048 let mut buf = Vec::new();
16049 loop {
16050 match reader.read_event_into(&mut buf)? {
16051 Event::End(_) => break,
16052 Event::Eof => break,
16053 _ => {}
16054 }
16055 buf.clear();
16056 }
16057 }
16058
16059 Ok(Self {
16060 name: f_name.ok_or_else(|| ParseError::MissingAttribute("name".to_string()))?,
16061 value: f_value.ok_or_else(|| ParseError::MissingAttribute("val".to_string()))?,
16062 #[cfg(feature = "extra-attrs")]
16063 extra_attrs,
16064 })
16065 }
16066}
16067
16068impl FromXml for CTTagList {
16069 fn from_xml<R: BufRead>(
16070 reader: &mut Reader<R>,
16071 start_tag: &BytesStart,
16072 is_empty: bool,
16073 ) -> Result<Self, ParseError> {
16074 let mut f_tag = Vec::new();
16075 #[cfg(feature = "extra-children")]
16076 let mut extra_children = Vec::new();
16077 #[cfg(feature = "extra-children")]
16078 let mut child_idx: usize = 0;
16079
16080 if !is_empty {
16082 let mut buf = Vec::new();
16083 loop {
16084 match reader.read_event_into(&mut buf)? {
16085 Event::Start(e) => {
16086 match e.local_name().as_ref() {
16087 b"tag" => {
16088 f_tag.push(CTStringTag::from_xml(reader, &e, false)?);
16089 #[cfg(feature = "extra-children")]
16090 {
16091 child_idx += 1;
16092 }
16093 }
16094 #[cfg(feature = "extra-children")]
16095 _ => {
16096 let elem = RawXmlElement::from_reader(reader, &e)?;
16098 extra_children.push(PositionedNode::new(
16099 child_idx,
16100 RawXmlNode::Element(elem),
16101 ));
16102 child_idx += 1;
16103 }
16104 #[cfg(not(feature = "extra-children"))]
16105 _ => {
16106 skip_element(reader)?;
16108 }
16109 }
16110 }
16111 Event::Empty(e) => {
16112 match e.local_name().as_ref() {
16113 b"tag" => {
16114 f_tag.push(CTStringTag::from_xml(reader, &e, true)?);
16115 #[cfg(feature = "extra-children")]
16116 {
16117 child_idx += 1;
16118 }
16119 }
16120 #[cfg(feature = "extra-children")]
16121 _ => {
16122 let elem = RawXmlElement::from_empty(&e);
16124 extra_children.push(PositionedNode::new(
16125 child_idx,
16126 RawXmlNode::Element(elem),
16127 ));
16128 child_idx += 1;
16129 }
16130 #[cfg(not(feature = "extra-children"))]
16131 _ => {}
16132 }
16133 }
16134 Event::End(_) => break,
16135 Event::Eof => break,
16136 _ => {}
16137 }
16138 buf.clear();
16139 }
16140 }
16141
16142 Ok(Self {
16143 tag: f_tag,
16144 #[cfg(feature = "extra-children")]
16145 extra_children,
16146 })
16147 }
16148}
16149
16150impl FromXml for CTNormalViewPortion {
16151 fn from_xml<R: BufRead>(
16152 reader: &mut Reader<R>,
16153 start_tag: &BytesStart,
16154 is_empty: bool,
16155 ) -> Result<Self, ParseError> {
16156 let mut f_sz: Option<ooxml_dml::types::STPositiveFixedPercentage> = None;
16157 let mut f_auto_adjust = None;
16158 #[cfg(feature = "extra-attrs")]
16159 let mut extra_attrs = std::collections::HashMap::new();
16160
16161 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
16163 let val = String::from_utf8_lossy(&attr.value);
16164 match attr.key.local_name().as_ref() {
16165 b"sz" => {
16166 f_sz = val.parse().ok();
16167 }
16168 b"autoAdjust" => {
16169 f_auto_adjust = Some(val == "true" || val == "1");
16170 }
16171 #[cfg(feature = "extra-attrs")]
16172 unknown => {
16173 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
16174 extra_attrs.insert(key, val.into_owned());
16175 }
16176 #[cfg(not(feature = "extra-attrs"))]
16177 _ => {}
16178 }
16179 }
16180
16181 if !is_empty {
16182 let mut buf = Vec::new();
16183 loop {
16184 match reader.read_event_into(&mut buf)? {
16185 Event::End(_) => break,
16186 Event::Eof => break,
16187 _ => {}
16188 }
16189 buf.clear();
16190 }
16191 }
16192
16193 Ok(Self {
16194 sz: f_sz.ok_or_else(|| ParseError::MissingAttribute("sz".to_string()))?,
16195 auto_adjust: f_auto_adjust,
16196 #[cfg(feature = "extra-attrs")]
16197 extra_attrs,
16198 })
16199 }
16200}
16201
16202impl FromXml for CTNormalViewProperties {
16203 fn from_xml<R: BufRead>(
16204 reader: &mut Reader<R>,
16205 start_tag: &BytesStart,
16206 is_empty: bool,
16207 ) -> Result<Self, ParseError> {
16208 let mut f_show_outline_icons = None;
16209 let mut f_snap_vert_splitter = None;
16210 let mut f_vert_bar_state = None;
16211 let mut f_horz_bar_state = None;
16212 let mut f_prefer_single_view = None;
16213 let mut f_restored_left: Option<Box<CTNormalViewPortion>> = None;
16214 let mut f_restored_top: Option<Box<CTNormalViewPortion>> = None;
16215 let mut f_ext_lst = None;
16216 #[cfg(feature = "extra-attrs")]
16217 let mut extra_attrs = std::collections::HashMap::new();
16218 #[cfg(feature = "extra-children")]
16219 let mut extra_children = Vec::new();
16220 #[cfg(feature = "extra-children")]
16221 let mut child_idx: usize = 0;
16222
16223 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
16225 let val = String::from_utf8_lossy(&attr.value);
16226 match attr.key.local_name().as_ref() {
16227 b"showOutlineIcons" => {
16228 f_show_outline_icons = Some(val == "true" || val == "1");
16229 }
16230 b"snapVertSplitter" => {
16231 f_snap_vert_splitter = Some(val == "true" || val == "1");
16232 }
16233 b"vertBarState" => {
16234 f_vert_bar_state = val.parse().ok();
16235 }
16236 b"horzBarState" => {
16237 f_horz_bar_state = val.parse().ok();
16238 }
16239 b"preferSingleView" => {
16240 f_prefer_single_view = Some(val == "true" || val == "1");
16241 }
16242 #[cfg(feature = "extra-attrs")]
16243 unknown => {
16244 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
16245 extra_attrs.insert(key, val.into_owned());
16246 }
16247 #[cfg(not(feature = "extra-attrs"))]
16248 _ => {}
16249 }
16250 }
16251
16252 if !is_empty {
16254 let mut buf = Vec::new();
16255 loop {
16256 match reader.read_event_into(&mut buf)? {
16257 Event::Start(e) => {
16258 match e.local_name().as_ref() {
16259 b"restoredLeft" => {
16260 f_restored_left = Some(Box::new(CTNormalViewPortion::from_xml(
16261 reader, &e, false,
16262 )?));
16263 #[cfg(feature = "extra-children")]
16264 {
16265 child_idx += 1;
16266 }
16267 }
16268 b"restoredTop" => {
16269 f_restored_top = Some(Box::new(CTNormalViewPortion::from_xml(
16270 reader, &e, false,
16271 )?));
16272 #[cfg(feature = "extra-children")]
16273 {
16274 child_idx += 1;
16275 }
16276 }
16277 b"extLst" => {
16278 f_ext_lst =
16279 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
16280 #[cfg(feature = "extra-children")]
16281 {
16282 child_idx += 1;
16283 }
16284 }
16285 #[cfg(feature = "extra-children")]
16286 _ => {
16287 let elem = RawXmlElement::from_reader(reader, &e)?;
16289 extra_children.push(PositionedNode::new(
16290 child_idx,
16291 RawXmlNode::Element(elem),
16292 ));
16293 child_idx += 1;
16294 }
16295 #[cfg(not(feature = "extra-children"))]
16296 _ => {
16297 skip_element(reader)?;
16299 }
16300 }
16301 }
16302 Event::Empty(e) => {
16303 match e.local_name().as_ref() {
16304 b"restoredLeft" => {
16305 f_restored_left = Some(Box::new(CTNormalViewPortion::from_xml(
16306 reader, &e, true,
16307 )?));
16308 #[cfg(feature = "extra-children")]
16309 {
16310 child_idx += 1;
16311 }
16312 }
16313 b"restoredTop" => {
16314 f_restored_top = Some(Box::new(CTNormalViewPortion::from_xml(
16315 reader, &e, true,
16316 )?));
16317 #[cfg(feature = "extra-children")]
16318 {
16319 child_idx += 1;
16320 }
16321 }
16322 b"extLst" => {
16323 f_ext_lst =
16324 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
16325 #[cfg(feature = "extra-children")]
16326 {
16327 child_idx += 1;
16328 }
16329 }
16330 #[cfg(feature = "extra-children")]
16331 _ => {
16332 let elem = RawXmlElement::from_empty(&e);
16334 extra_children.push(PositionedNode::new(
16335 child_idx,
16336 RawXmlNode::Element(elem),
16337 ));
16338 child_idx += 1;
16339 }
16340 #[cfg(not(feature = "extra-children"))]
16341 _ => {}
16342 }
16343 }
16344 Event::End(_) => break,
16345 Event::Eof => break,
16346 _ => {}
16347 }
16348 buf.clear();
16349 }
16350 }
16351
16352 Ok(Self {
16353 show_outline_icons: f_show_outline_icons,
16354 snap_vert_splitter: f_snap_vert_splitter,
16355 vert_bar_state: f_vert_bar_state,
16356 horz_bar_state: f_horz_bar_state,
16357 prefer_single_view: f_prefer_single_view,
16358 restored_left: f_restored_left
16359 .ok_or_else(|| ParseError::MissingAttribute("restoredLeft".to_string()))?,
16360 restored_top: f_restored_top
16361 .ok_or_else(|| ParseError::MissingAttribute("restoredTop".to_string()))?,
16362 ext_lst: f_ext_lst,
16363 #[cfg(feature = "extra-attrs")]
16364 extra_attrs,
16365 #[cfg(feature = "extra-children")]
16366 extra_children,
16367 })
16368 }
16369}
16370
16371impl FromXml for CTCommonViewProperties {
16372 fn from_xml<R: BufRead>(
16373 reader: &mut Reader<R>,
16374 start_tag: &BytesStart,
16375 is_empty: bool,
16376 ) -> Result<Self, ParseError> {
16377 let mut f_var_scale = None;
16378 let mut f_scale: Option<Box<ooxml_dml::types::CTScale2D>> = None;
16379 let mut f_origin: Option<Box<ooxml_dml::types::Point2D>> = None;
16380 #[cfg(feature = "extra-attrs")]
16381 let mut extra_attrs = std::collections::HashMap::new();
16382 #[cfg(feature = "extra-children")]
16383 let mut extra_children = Vec::new();
16384 #[cfg(feature = "extra-children")]
16385 let mut child_idx: usize = 0;
16386
16387 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
16389 let val = String::from_utf8_lossy(&attr.value);
16390 match attr.key.local_name().as_ref() {
16391 b"varScale" => {
16392 f_var_scale = Some(val == "true" || val == "1");
16393 }
16394 #[cfg(feature = "extra-attrs")]
16395 unknown => {
16396 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
16397 extra_attrs.insert(key, val.into_owned());
16398 }
16399 #[cfg(not(feature = "extra-attrs"))]
16400 _ => {}
16401 }
16402 }
16403
16404 if !is_empty {
16406 let mut buf = Vec::new();
16407 loop {
16408 match reader.read_event_into(&mut buf)? {
16409 Event::Start(e) => {
16410 match e.local_name().as_ref() {
16411 b"scale" => {
16412 f_scale = Some(Box::new(ooxml_dml::types::CTScale2D::from_xml(
16413 reader, &e, false,
16414 )?));
16415 #[cfg(feature = "extra-children")]
16416 {
16417 child_idx += 1;
16418 }
16419 }
16420 b"origin" => {
16421 f_origin = Some(Box::new(ooxml_dml::types::Point2D::from_xml(
16422 reader, &e, false,
16423 )?));
16424 #[cfg(feature = "extra-children")]
16425 {
16426 child_idx += 1;
16427 }
16428 }
16429 #[cfg(feature = "extra-children")]
16430 _ => {
16431 let elem = RawXmlElement::from_reader(reader, &e)?;
16433 extra_children.push(PositionedNode::new(
16434 child_idx,
16435 RawXmlNode::Element(elem),
16436 ));
16437 child_idx += 1;
16438 }
16439 #[cfg(not(feature = "extra-children"))]
16440 _ => {
16441 skip_element(reader)?;
16443 }
16444 }
16445 }
16446 Event::Empty(e) => {
16447 match e.local_name().as_ref() {
16448 b"scale" => {
16449 f_scale = Some(Box::new(ooxml_dml::types::CTScale2D::from_xml(
16450 reader, &e, true,
16451 )?));
16452 #[cfg(feature = "extra-children")]
16453 {
16454 child_idx += 1;
16455 }
16456 }
16457 b"origin" => {
16458 f_origin = Some(Box::new(ooxml_dml::types::Point2D::from_xml(
16459 reader, &e, true,
16460 )?));
16461 #[cfg(feature = "extra-children")]
16462 {
16463 child_idx += 1;
16464 }
16465 }
16466 #[cfg(feature = "extra-children")]
16467 _ => {
16468 let elem = RawXmlElement::from_empty(&e);
16470 extra_children.push(PositionedNode::new(
16471 child_idx,
16472 RawXmlNode::Element(elem),
16473 ));
16474 child_idx += 1;
16475 }
16476 #[cfg(not(feature = "extra-children"))]
16477 _ => {}
16478 }
16479 }
16480 Event::End(_) => break,
16481 Event::Eof => break,
16482 _ => {}
16483 }
16484 buf.clear();
16485 }
16486 }
16487
16488 Ok(Self {
16489 var_scale: f_var_scale,
16490 scale: f_scale.ok_or_else(|| ParseError::MissingAttribute("scale".to_string()))?,
16491 origin: f_origin.ok_or_else(|| ParseError::MissingAttribute("origin".to_string()))?,
16492 #[cfg(feature = "extra-attrs")]
16493 extra_attrs,
16494 #[cfg(feature = "extra-children")]
16495 extra_children,
16496 })
16497 }
16498}
16499
16500impl FromXml for CTNotesTextViewProperties {
16501 fn from_xml<R: BufRead>(
16502 reader: &mut Reader<R>,
16503 start_tag: &BytesStart,
16504 is_empty: bool,
16505 ) -> Result<Self, ParseError> {
16506 let mut f_c_view_pr: Option<Box<CTCommonViewProperties>> = None;
16507 let mut f_ext_lst = None;
16508 #[cfg(feature = "extra-children")]
16509 let mut extra_children = Vec::new();
16510 #[cfg(feature = "extra-children")]
16511 let mut child_idx: usize = 0;
16512
16513 if !is_empty {
16515 let mut buf = Vec::new();
16516 loop {
16517 match reader.read_event_into(&mut buf)? {
16518 Event::Start(e) => {
16519 match e.local_name().as_ref() {
16520 b"cViewPr" => {
16521 f_c_view_pr = Some(Box::new(CTCommonViewProperties::from_xml(
16522 reader, &e, false,
16523 )?));
16524 #[cfg(feature = "extra-children")]
16525 {
16526 child_idx += 1;
16527 }
16528 }
16529 b"extLst" => {
16530 f_ext_lst =
16531 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
16532 #[cfg(feature = "extra-children")]
16533 {
16534 child_idx += 1;
16535 }
16536 }
16537 #[cfg(feature = "extra-children")]
16538 _ => {
16539 let elem = RawXmlElement::from_reader(reader, &e)?;
16541 extra_children.push(PositionedNode::new(
16542 child_idx,
16543 RawXmlNode::Element(elem),
16544 ));
16545 child_idx += 1;
16546 }
16547 #[cfg(not(feature = "extra-children"))]
16548 _ => {
16549 skip_element(reader)?;
16551 }
16552 }
16553 }
16554 Event::Empty(e) => {
16555 match e.local_name().as_ref() {
16556 b"cViewPr" => {
16557 f_c_view_pr = Some(Box::new(CTCommonViewProperties::from_xml(
16558 reader, &e, true,
16559 )?));
16560 #[cfg(feature = "extra-children")]
16561 {
16562 child_idx += 1;
16563 }
16564 }
16565 b"extLst" => {
16566 f_ext_lst =
16567 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
16568 #[cfg(feature = "extra-children")]
16569 {
16570 child_idx += 1;
16571 }
16572 }
16573 #[cfg(feature = "extra-children")]
16574 _ => {
16575 let elem = RawXmlElement::from_empty(&e);
16577 extra_children.push(PositionedNode::new(
16578 child_idx,
16579 RawXmlNode::Element(elem),
16580 ));
16581 child_idx += 1;
16582 }
16583 #[cfg(not(feature = "extra-children"))]
16584 _ => {}
16585 }
16586 }
16587 Event::End(_) => break,
16588 Event::Eof => break,
16589 _ => {}
16590 }
16591 buf.clear();
16592 }
16593 }
16594
16595 Ok(Self {
16596 c_view_pr: f_c_view_pr
16597 .ok_or_else(|| ParseError::MissingAttribute("cViewPr".to_string()))?,
16598 ext_lst: f_ext_lst,
16599 #[cfg(feature = "extra-children")]
16600 extra_children,
16601 })
16602 }
16603}
16604
16605impl FromXml for CTOutlineViewSlideEntry {
16606 fn from_xml<R: BufRead>(
16607 reader: &mut Reader<R>,
16608 start_tag: &BytesStart,
16609 is_empty: bool,
16610 ) -> Result<Self, ParseError> {
16611 let mut f_collapse = None;
16612 #[cfg(feature = "extra-attrs")]
16613 let mut extra_attrs = std::collections::HashMap::new();
16614
16615 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
16617 let val = String::from_utf8_lossy(&attr.value);
16618 match attr.key.local_name().as_ref() {
16619 b"collapse" => {
16620 f_collapse = Some(val == "true" || val == "1");
16621 }
16622 #[cfg(feature = "extra-attrs")]
16623 unknown => {
16624 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
16625 extra_attrs.insert(key, val.into_owned());
16626 }
16627 #[cfg(not(feature = "extra-attrs"))]
16628 _ => {}
16629 }
16630 }
16631
16632 if !is_empty {
16633 let mut buf = Vec::new();
16634 loop {
16635 match reader.read_event_into(&mut buf)? {
16636 Event::End(_) => break,
16637 Event::Eof => break,
16638 _ => {}
16639 }
16640 buf.clear();
16641 }
16642 }
16643
16644 Ok(Self {
16645 collapse: f_collapse,
16646 #[cfg(feature = "extra-attrs")]
16647 extra_attrs,
16648 })
16649 }
16650}
16651
16652impl FromXml for CTOutlineViewSlideList {
16653 fn from_xml<R: BufRead>(
16654 reader: &mut Reader<R>,
16655 start_tag: &BytesStart,
16656 is_empty: bool,
16657 ) -> Result<Self, ParseError> {
16658 let mut f_sld = Vec::new();
16659 #[cfg(feature = "extra-children")]
16660 let mut extra_children = Vec::new();
16661 #[cfg(feature = "extra-children")]
16662 let mut child_idx: usize = 0;
16663
16664 if !is_empty {
16666 let mut buf = Vec::new();
16667 loop {
16668 match reader.read_event_into(&mut buf)? {
16669 Event::Start(e) => {
16670 match e.local_name().as_ref() {
16671 b"sld" => {
16672 f_sld.push(CTOutlineViewSlideEntry::from_xml(reader, &e, false)?);
16673 #[cfg(feature = "extra-children")]
16674 {
16675 child_idx += 1;
16676 }
16677 }
16678 #[cfg(feature = "extra-children")]
16679 _ => {
16680 let elem = RawXmlElement::from_reader(reader, &e)?;
16682 extra_children.push(PositionedNode::new(
16683 child_idx,
16684 RawXmlNode::Element(elem),
16685 ));
16686 child_idx += 1;
16687 }
16688 #[cfg(not(feature = "extra-children"))]
16689 _ => {
16690 skip_element(reader)?;
16692 }
16693 }
16694 }
16695 Event::Empty(e) => {
16696 match e.local_name().as_ref() {
16697 b"sld" => {
16698 f_sld.push(CTOutlineViewSlideEntry::from_xml(reader, &e, true)?);
16699 #[cfg(feature = "extra-children")]
16700 {
16701 child_idx += 1;
16702 }
16703 }
16704 #[cfg(feature = "extra-children")]
16705 _ => {
16706 let elem = RawXmlElement::from_empty(&e);
16708 extra_children.push(PositionedNode::new(
16709 child_idx,
16710 RawXmlNode::Element(elem),
16711 ));
16712 child_idx += 1;
16713 }
16714 #[cfg(not(feature = "extra-children"))]
16715 _ => {}
16716 }
16717 }
16718 Event::End(_) => break,
16719 Event::Eof => break,
16720 _ => {}
16721 }
16722 buf.clear();
16723 }
16724 }
16725
16726 Ok(Self {
16727 sld: f_sld,
16728 #[cfg(feature = "extra-children")]
16729 extra_children,
16730 })
16731 }
16732}
16733
16734impl FromXml for CTOutlineViewProperties {
16735 fn from_xml<R: BufRead>(
16736 reader: &mut Reader<R>,
16737 start_tag: &BytesStart,
16738 is_empty: bool,
16739 ) -> Result<Self, ParseError> {
16740 let mut f_c_view_pr: Option<Box<CTCommonViewProperties>> = None;
16741 let mut f_sld_lst = None;
16742 let mut f_ext_lst = None;
16743 #[cfg(feature = "extra-children")]
16744 let mut extra_children = Vec::new();
16745 #[cfg(feature = "extra-children")]
16746 let mut child_idx: usize = 0;
16747
16748 if !is_empty {
16750 let mut buf = Vec::new();
16751 loop {
16752 match reader.read_event_into(&mut buf)? {
16753 Event::Start(e) => {
16754 match e.local_name().as_ref() {
16755 b"cViewPr" => {
16756 f_c_view_pr = Some(Box::new(CTCommonViewProperties::from_xml(
16757 reader, &e, false,
16758 )?));
16759 #[cfg(feature = "extra-children")]
16760 {
16761 child_idx += 1;
16762 }
16763 }
16764 b"sldLst" => {
16765 f_sld_lst = Some(Box::new(CTOutlineViewSlideList::from_xml(
16766 reader, &e, false,
16767 )?));
16768 #[cfg(feature = "extra-children")]
16769 {
16770 child_idx += 1;
16771 }
16772 }
16773 b"extLst" => {
16774 f_ext_lst =
16775 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
16776 #[cfg(feature = "extra-children")]
16777 {
16778 child_idx += 1;
16779 }
16780 }
16781 #[cfg(feature = "extra-children")]
16782 _ => {
16783 let elem = RawXmlElement::from_reader(reader, &e)?;
16785 extra_children.push(PositionedNode::new(
16786 child_idx,
16787 RawXmlNode::Element(elem),
16788 ));
16789 child_idx += 1;
16790 }
16791 #[cfg(not(feature = "extra-children"))]
16792 _ => {
16793 skip_element(reader)?;
16795 }
16796 }
16797 }
16798 Event::Empty(e) => {
16799 match e.local_name().as_ref() {
16800 b"cViewPr" => {
16801 f_c_view_pr = Some(Box::new(CTCommonViewProperties::from_xml(
16802 reader, &e, true,
16803 )?));
16804 #[cfg(feature = "extra-children")]
16805 {
16806 child_idx += 1;
16807 }
16808 }
16809 b"sldLst" => {
16810 f_sld_lst = Some(Box::new(CTOutlineViewSlideList::from_xml(
16811 reader, &e, true,
16812 )?));
16813 #[cfg(feature = "extra-children")]
16814 {
16815 child_idx += 1;
16816 }
16817 }
16818 b"extLst" => {
16819 f_ext_lst =
16820 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
16821 #[cfg(feature = "extra-children")]
16822 {
16823 child_idx += 1;
16824 }
16825 }
16826 #[cfg(feature = "extra-children")]
16827 _ => {
16828 let elem = RawXmlElement::from_empty(&e);
16830 extra_children.push(PositionedNode::new(
16831 child_idx,
16832 RawXmlNode::Element(elem),
16833 ));
16834 child_idx += 1;
16835 }
16836 #[cfg(not(feature = "extra-children"))]
16837 _ => {}
16838 }
16839 }
16840 Event::End(_) => break,
16841 Event::Eof => break,
16842 _ => {}
16843 }
16844 buf.clear();
16845 }
16846 }
16847
16848 Ok(Self {
16849 c_view_pr: f_c_view_pr
16850 .ok_or_else(|| ParseError::MissingAttribute("cViewPr".to_string()))?,
16851 sld_lst: f_sld_lst,
16852 ext_lst: f_ext_lst,
16853 #[cfg(feature = "extra-children")]
16854 extra_children,
16855 })
16856 }
16857}
16858
16859impl FromXml for CTSlideSorterViewProperties {
16860 fn from_xml<R: BufRead>(
16861 reader: &mut Reader<R>,
16862 start_tag: &BytesStart,
16863 is_empty: bool,
16864 ) -> Result<Self, ParseError> {
16865 let mut f_show_formatting = None;
16866 let mut f_c_view_pr: Option<Box<CTCommonViewProperties>> = None;
16867 let mut f_ext_lst = None;
16868 #[cfg(feature = "extra-attrs")]
16869 let mut extra_attrs = std::collections::HashMap::new();
16870 #[cfg(feature = "extra-children")]
16871 let mut extra_children = Vec::new();
16872 #[cfg(feature = "extra-children")]
16873 let mut child_idx: usize = 0;
16874
16875 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
16877 let val = String::from_utf8_lossy(&attr.value);
16878 match attr.key.local_name().as_ref() {
16879 b"showFormatting" => {
16880 f_show_formatting = Some(val == "true" || val == "1");
16881 }
16882 #[cfg(feature = "extra-attrs")]
16883 unknown => {
16884 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
16885 extra_attrs.insert(key, val.into_owned());
16886 }
16887 #[cfg(not(feature = "extra-attrs"))]
16888 _ => {}
16889 }
16890 }
16891
16892 if !is_empty {
16894 let mut buf = Vec::new();
16895 loop {
16896 match reader.read_event_into(&mut buf)? {
16897 Event::Start(e) => {
16898 match e.local_name().as_ref() {
16899 b"cViewPr" => {
16900 f_c_view_pr = Some(Box::new(CTCommonViewProperties::from_xml(
16901 reader, &e, false,
16902 )?));
16903 #[cfg(feature = "extra-children")]
16904 {
16905 child_idx += 1;
16906 }
16907 }
16908 b"extLst" => {
16909 f_ext_lst =
16910 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
16911 #[cfg(feature = "extra-children")]
16912 {
16913 child_idx += 1;
16914 }
16915 }
16916 #[cfg(feature = "extra-children")]
16917 _ => {
16918 let elem = RawXmlElement::from_reader(reader, &e)?;
16920 extra_children.push(PositionedNode::new(
16921 child_idx,
16922 RawXmlNode::Element(elem),
16923 ));
16924 child_idx += 1;
16925 }
16926 #[cfg(not(feature = "extra-children"))]
16927 _ => {
16928 skip_element(reader)?;
16930 }
16931 }
16932 }
16933 Event::Empty(e) => {
16934 match e.local_name().as_ref() {
16935 b"cViewPr" => {
16936 f_c_view_pr = Some(Box::new(CTCommonViewProperties::from_xml(
16937 reader, &e, true,
16938 )?));
16939 #[cfg(feature = "extra-children")]
16940 {
16941 child_idx += 1;
16942 }
16943 }
16944 b"extLst" => {
16945 f_ext_lst =
16946 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
16947 #[cfg(feature = "extra-children")]
16948 {
16949 child_idx += 1;
16950 }
16951 }
16952 #[cfg(feature = "extra-children")]
16953 _ => {
16954 let elem = RawXmlElement::from_empty(&e);
16956 extra_children.push(PositionedNode::new(
16957 child_idx,
16958 RawXmlNode::Element(elem),
16959 ));
16960 child_idx += 1;
16961 }
16962 #[cfg(not(feature = "extra-children"))]
16963 _ => {}
16964 }
16965 }
16966 Event::End(_) => break,
16967 Event::Eof => break,
16968 _ => {}
16969 }
16970 buf.clear();
16971 }
16972 }
16973
16974 Ok(Self {
16975 show_formatting: f_show_formatting,
16976 c_view_pr: f_c_view_pr
16977 .ok_or_else(|| ParseError::MissingAttribute("cViewPr".to_string()))?,
16978 ext_lst: f_ext_lst,
16979 #[cfg(feature = "extra-attrs")]
16980 extra_attrs,
16981 #[cfg(feature = "extra-children")]
16982 extra_children,
16983 })
16984 }
16985}
16986
16987impl FromXml for CTGuide {
16988 fn from_xml<R: BufRead>(
16989 reader: &mut Reader<R>,
16990 start_tag: &BytesStart,
16991 is_empty: bool,
16992 ) -> Result<Self, ParseError> {
16993 let mut f_orient = None;
16994 let mut f_pos = None;
16995 #[cfg(feature = "extra-attrs")]
16996 let mut extra_attrs = std::collections::HashMap::new();
16997
16998 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
17000 let val = String::from_utf8_lossy(&attr.value);
17001 match attr.key.local_name().as_ref() {
17002 b"orient" => {
17003 f_orient = val.parse().ok();
17004 }
17005 b"pos" => {
17006 f_pos = val.parse().ok();
17007 }
17008 #[cfg(feature = "extra-attrs")]
17009 unknown => {
17010 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
17011 extra_attrs.insert(key, val.into_owned());
17012 }
17013 #[cfg(not(feature = "extra-attrs"))]
17014 _ => {}
17015 }
17016 }
17017
17018 if !is_empty {
17019 let mut buf = Vec::new();
17020 loop {
17021 match reader.read_event_into(&mut buf)? {
17022 Event::End(_) => break,
17023 Event::Eof => break,
17024 _ => {}
17025 }
17026 buf.clear();
17027 }
17028 }
17029
17030 Ok(Self {
17031 orient: f_orient,
17032 pos: f_pos,
17033 #[cfg(feature = "extra-attrs")]
17034 extra_attrs,
17035 })
17036 }
17037}
17038
17039impl FromXml for CTGuideList {
17040 fn from_xml<R: BufRead>(
17041 reader: &mut Reader<R>,
17042 start_tag: &BytesStart,
17043 is_empty: bool,
17044 ) -> Result<Self, ParseError> {
17045 let mut f_guide = Vec::new();
17046 #[cfg(feature = "extra-children")]
17047 let mut extra_children = Vec::new();
17048 #[cfg(feature = "extra-children")]
17049 let mut child_idx: usize = 0;
17050
17051 if !is_empty {
17053 let mut buf = Vec::new();
17054 loop {
17055 match reader.read_event_into(&mut buf)? {
17056 Event::Start(e) => {
17057 match e.local_name().as_ref() {
17058 b"guide" => {
17059 f_guide.push(CTGuide::from_xml(reader, &e, false)?);
17060 #[cfg(feature = "extra-children")]
17061 {
17062 child_idx += 1;
17063 }
17064 }
17065 #[cfg(feature = "extra-children")]
17066 _ => {
17067 let elem = RawXmlElement::from_reader(reader, &e)?;
17069 extra_children.push(PositionedNode::new(
17070 child_idx,
17071 RawXmlNode::Element(elem),
17072 ));
17073 child_idx += 1;
17074 }
17075 #[cfg(not(feature = "extra-children"))]
17076 _ => {
17077 skip_element(reader)?;
17079 }
17080 }
17081 }
17082 Event::Empty(e) => {
17083 match e.local_name().as_ref() {
17084 b"guide" => {
17085 f_guide.push(CTGuide::from_xml(reader, &e, true)?);
17086 #[cfg(feature = "extra-children")]
17087 {
17088 child_idx += 1;
17089 }
17090 }
17091 #[cfg(feature = "extra-children")]
17092 _ => {
17093 let elem = RawXmlElement::from_empty(&e);
17095 extra_children.push(PositionedNode::new(
17096 child_idx,
17097 RawXmlNode::Element(elem),
17098 ));
17099 child_idx += 1;
17100 }
17101 #[cfg(not(feature = "extra-children"))]
17102 _ => {}
17103 }
17104 }
17105 Event::End(_) => break,
17106 Event::Eof => break,
17107 _ => {}
17108 }
17109 buf.clear();
17110 }
17111 }
17112
17113 Ok(Self {
17114 guide: f_guide,
17115 #[cfg(feature = "extra-children")]
17116 extra_children,
17117 })
17118 }
17119}
17120
17121impl FromXml for CTCommonSlideViewProperties {
17122 fn from_xml<R: BufRead>(
17123 reader: &mut Reader<R>,
17124 start_tag: &BytesStart,
17125 is_empty: bool,
17126 ) -> Result<Self, ParseError> {
17127 let mut f_snap_to_grid = None;
17128 let mut f_snap_to_objects = None;
17129 let mut f_show_guides = None;
17130 let mut f_c_view_pr: Option<Box<CTCommonViewProperties>> = None;
17131 let mut f_guide_lst = None;
17132 #[cfg(feature = "extra-attrs")]
17133 let mut extra_attrs = std::collections::HashMap::new();
17134 #[cfg(feature = "extra-children")]
17135 let mut extra_children = Vec::new();
17136 #[cfg(feature = "extra-children")]
17137 let mut child_idx: usize = 0;
17138
17139 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
17141 let val = String::from_utf8_lossy(&attr.value);
17142 match attr.key.local_name().as_ref() {
17143 b"snapToGrid" => {
17144 f_snap_to_grid = Some(val == "true" || val == "1");
17145 }
17146 b"snapToObjects" => {
17147 f_snap_to_objects = Some(val == "true" || val == "1");
17148 }
17149 b"showGuides" => {
17150 f_show_guides = Some(val == "true" || val == "1");
17151 }
17152 #[cfg(feature = "extra-attrs")]
17153 unknown => {
17154 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
17155 extra_attrs.insert(key, val.into_owned());
17156 }
17157 #[cfg(not(feature = "extra-attrs"))]
17158 _ => {}
17159 }
17160 }
17161
17162 if !is_empty {
17164 let mut buf = Vec::new();
17165 loop {
17166 match reader.read_event_into(&mut buf)? {
17167 Event::Start(e) => {
17168 match e.local_name().as_ref() {
17169 b"cViewPr" => {
17170 f_c_view_pr = Some(Box::new(CTCommonViewProperties::from_xml(
17171 reader, &e, false,
17172 )?));
17173 #[cfg(feature = "extra-children")]
17174 {
17175 child_idx += 1;
17176 }
17177 }
17178 b"guideLst" => {
17179 f_guide_lst =
17180 Some(Box::new(CTGuideList::from_xml(reader, &e, false)?));
17181 #[cfg(feature = "extra-children")]
17182 {
17183 child_idx += 1;
17184 }
17185 }
17186 #[cfg(feature = "extra-children")]
17187 _ => {
17188 let elem = RawXmlElement::from_reader(reader, &e)?;
17190 extra_children.push(PositionedNode::new(
17191 child_idx,
17192 RawXmlNode::Element(elem),
17193 ));
17194 child_idx += 1;
17195 }
17196 #[cfg(not(feature = "extra-children"))]
17197 _ => {
17198 skip_element(reader)?;
17200 }
17201 }
17202 }
17203 Event::Empty(e) => {
17204 match e.local_name().as_ref() {
17205 b"cViewPr" => {
17206 f_c_view_pr = Some(Box::new(CTCommonViewProperties::from_xml(
17207 reader, &e, true,
17208 )?));
17209 #[cfg(feature = "extra-children")]
17210 {
17211 child_idx += 1;
17212 }
17213 }
17214 b"guideLst" => {
17215 f_guide_lst =
17216 Some(Box::new(CTGuideList::from_xml(reader, &e, true)?));
17217 #[cfg(feature = "extra-children")]
17218 {
17219 child_idx += 1;
17220 }
17221 }
17222 #[cfg(feature = "extra-children")]
17223 _ => {
17224 let elem = RawXmlElement::from_empty(&e);
17226 extra_children.push(PositionedNode::new(
17227 child_idx,
17228 RawXmlNode::Element(elem),
17229 ));
17230 child_idx += 1;
17231 }
17232 #[cfg(not(feature = "extra-children"))]
17233 _ => {}
17234 }
17235 }
17236 Event::End(_) => break,
17237 Event::Eof => break,
17238 _ => {}
17239 }
17240 buf.clear();
17241 }
17242 }
17243
17244 Ok(Self {
17245 snap_to_grid: f_snap_to_grid,
17246 snap_to_objects: f_snap_to_objects,
17247 show_guides: f_show_guides,
17248 c_view_pr: f_c_view_pr
17249 .ok_or_else(|| ParseError::MissingAttribute("cViewPr".to_string()))?,
17250 guide_lst: f_guide_lst,
17251 #[cfg(feature = "extra-attrs")]
17252 extra_attrs,
17253 #[cfg(feature = "extra-children")]
17254 extra_children,
17255 })
17256 }
17257}
17258
17259impl FromXml for CTSlideViewProperties {
17260 fn from_xml<R: BufRead>(
17261 reader: &mut Reader<R>,
17262 start_tag: &BytesStart,
17263 is_empty: bool,
17264 ) -> Result<Self, ParseError> {
17265 let mut f_c_sld_view_pr: Option<Box<CTCommonSlideViewProperties>> = None;
17266 let mut f_ext_lst = None;
17267 #[cfg(feature = "extra-children")]
17268 let mut extra_children = Vec::new();
17269 #[cfg(feature = "extra-children")]
17270 let mut child_idx: usize = 0;
17271
17272 if !is_empty {
17274 let mut buf = Vec::new();
17275 loop {
17276 match reader.read_event_into(&mut buf)? {
17277 Event::Start(e) => {
17278 match e.local_name().as_ref() {
17279 b"cSldViewPr" => {
17280 f_c_sld_view_pr = Some(Box::new(
17281 CTCommonSlideViewProperties::from_xml(reader, &e, false)?,
17282 ));
17283 #[cfg(feature = "extra-children")]
17284 {
17285 child_idx += 1;
17286 }
17287 }
17288 b"extLst" => {
17289 f_ext_lst =
17290 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
17291 #[cfg(feature = "extra-children")]
17292 {
17293 child_idx += 1;
17294 }
17295 }
17296 #[cfg(feature = "extra-children")]
17297 _ => {
17298 let elem = RawXmlElement::from_reader(reader, &e)?;
17300 extra_children.push(PositionedNode::new(
17301 child_idx,
17302 RawXmlNode::Element(elem),
17303 ));
17304 child_idx += 1;
17305 }
17306 #[cfg(not(feature = "extra-children"))]
17307 _ => {
17308 skip_element(reader)?;
17310 }
17311 }
17312 }
17313 Event::Empty(e) => {
17314 match e.local_name().as_ref() {
17315 b"cSldViewPr" => {
17316 f_c_sld_view_pr = Some(Box::new(
17317 CTCommonSlideViewProperties::from_xml(reader, &e, true)?,
17318 ));
17319 #[cfg(feature = "extra-children")]
17320 {
17321 child_idx += 1;
17322 }
17323 }
17324 b"extLst" => {
17325 f_ext_lst =
17326 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
17327 #[cfg(feature = "extra-children")]
17328 {
17329 child_idx += 1;
17330 }
17331 }
17332 #[cfg(feature = "extra-children")]
17333 _ => {
17334 let elem = RawXmlElement::from_empty(&e);
17336 extra_children.push(PositionedNode::new(
17337 child_idx,
17338 RawXmlNode::Element(elem),
17339 ));
17340 child_idx += 1;
17341 }
17342 #[cfg(not(feature = "extra-children"))]
17343 _ => {}
17344 }
17345 }
17346 Event::End(_) => break,
17347 Event::Eof => break,
17348 _ => {}
17349 }
17350 buf.clear();
17351 }
17352 }
17353
17354 Ok(Self {
17355 c_sld_view_pr: f_c_sld_view_pr
17356 .ok_or_else(|| ParseError::MissingAttribute("cSldViewPr".to_string()))?,
17357 ext_lst: f_ext_lst,
17358 #[cfg(feature = "extra-children")]
17359 extra_children,
17360 })
17361 }
17362}
17363
17364impl FromXml for CTNotesViewProperties {
17365 fn from_xml<R: BufRead>(
17366 reader: &mut Reader<R>,
17367 start_tag: &BytesStart,
17368 is_empty: bool,
17369 ) -> Result<Self, ParseError> {
17370 let mut f_c_sld_view_pr: Option<Box<CTCommonSlideViewProperties>> = None;
17371 let mut f_ext_lst = None;
17372 #[cfg(feature = "extra-children")]
17373 let mut extra_children = Vec::new();
17374 #[cfg(feature = "extra-children")]
17375 let mut child_idx: usize = 0;
17376
17377 if !is_empty {
17379 let mut buf = Vec::new();
17380 loop {
17381 match reader.read_event_into(&mut buf)? {
17382 Event::Start(e) => {
17383 match e.local_name().as_ref() {
17384 b"cSldViewPr" => {
17385 f_c_sld_view_pr = Some(Box::new(
17386 CTCommonSlideViewProperties::from_xml(reader, &e, false)?,
17387 ));
17388 #[cfg(feature = "extra-children")]
17389 {
17390 child_idx += 1;
17391 }
17392 }
17393 b"extLst" => {
17394 f_ext_lst =
17395 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
17396 #[cfg(feature = "extra-children")]
17397 {
17398 child_idx += 1;
17399 }
17400 }
17401 #[cfg(feature = "extra-children")]
17402 _ => {
17403 let elem = RawXmlElement::from_reader(reader, &e)?;
17405 extra_children.push(PositionedNode::new(
17406 child_idx,
17407 RawXmlNode::Element(elem),
17408 ));
17409 child_idx += 1;
17410 }
17411 #[cfg(not(feature = "extra-children"))]
17412 _ => {
17413 skip_element(reader)?;
17415 }
17416 }
17417 }
17418 Event::Empty(e) => {
17419 match e.local_name().as_ref() {
17420 b"cSldViewPr" => {
17421 f_c_sld_view_pr = Some(Box::new(
17422 CTCommonSlideViewProperties::from_xml(reader, &e, true)?,
17423 ));
17424 #[cfg(feature = "extra-children")]
17425 {
17426 child_idx += 1;
17427 }
17428 }
17429 b"extLst" => {
17430 f_ext_lst =
17431 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
17432 #[cfg(feature = "extra-children")]
17433 {
17434 child_idx += 1;
17435 }
17436 }
17437 #[cfg(feature = "extra-children")]
17438 _ => {
17439 let elem = RawXmlElement::from_empty(&e);
17441 extra_children.push(PositionedNode::new(
17442 child_idx,
17443 RawXmlNode::Element(elem),
17444 ));
17445 child_idx += 1;
17446 }
17447 #[cfg(not(feature = "extra-children"))]
17448 _ => {}
17449 }
17450 }
17451 Event::End(_) => break,
17452 Event::Eof => break,
17453 _ => {}
17454 }
17455 buf.clear();
17456 }
17457 }
17458
17459 Ok(Self {
17460 c_sld_view_pr: f_c_sld_view_pr
17461 .ok_or_else(|| ParseError::MissingAttribute("cSldViewPr".to_string()))?,
17462 ext_lst: f_ext_lst,
17463 #[cfg(feature = "extra-children")]
17464 extra_children,
17465 })
17466 }
17467}
17468
17469impl FromXml for CTViewProperties {
17470 fn from_xml<R: BufRead>(
17471 reader: &mut Reader<R>,
17472 start_tag: &BytesStart,
17473 is_empty: bool,
17474 ) -> Result<Self, ParseError> {
17475 let mut f_last_view = None;
17476 #[cfg(feature = "pml-comments")]
17477 let mut f_show_comments = None;
17478 let mut f_normal_view_pr = None;
17479 let mut f_slide_view_pr = None;
17480 let mut f_outline_view_pr = None;
17481 #[cfg(feature = "pml-notes")]
17482 let mut f_notes_text_view_pr = None;
17483 let mut f_sorter_view_pr = None;
17484 #[cfg(feature = "pml-notes")]
17485 let mut f_notes_view_pr = None;
17486 let mut f_grid_spacing = None;
17487 #[cfg(feature = "pml-extensions")]
17488 let mut f_ext_lst = None;
17489 #[cfg(feature = "extra-attrs")]
17490 let mut extra_attrs = std::collections::HashMap::new();
17491 #[cfg(feature = "extra-children")]
17492 let mut extra_children = Vec::new();
17493 #[cfg(feature = "extra-children")]
17494 let mut child_idx: usize = 0;
17495
17496 for attr in start_tag.attributes().filter_map(|a| a.ok()) {
17498 let val = String::from_utf8_lossy(&attr.value);
17499 match attr.key.local_name().as_ref() {
17500 b"lastView" => {
17501 f_last_view = val.parse().ok();
17502 }
17503 #[cfg(feature = "pml-comments")]
17504 b"showComments" => {
17505 f_show_comments = Some(val == "true" || val == "1");
17506 }
17507 #[cfg(feature = "extra-attrs")]
17508 unknown => {
17509 let key = String::from_utf8_lossy(attr.key.as_ref()).into_owned();
17510 extra_attrs.insert(key, val.into_owned());
17511 }
17512 #[cfg(not(feature = "extra-attrs"))]
17513 _ => {}
17514 }
17515 }
17516
17517 if !is_empty {
17519 let mut buf = Vec::new();
17520 loop {
17521 match reader.read_event_into(&mut buf)? {
17522 Event::Start(e) => {
17523 match e.local_name().as_ref() {
17524 b"normalViewPr" => {
17525 f_normal_view_pr = Some(Box::new(
17526 CTNormalViewProperties::from_xml(reader, &e, false)?,
17527 ));
17528 #[cfg(feature = "extra-children")]
17529 {
17530 child_idx += 1;
17531 }
17532 }
17533 b"slideViewPr" => {
17534 f_slide_view_pr = Some(Box::new(CTSlideViewProperties::from_xml(
17535 reader, &e, false,
17536 )?));
17537 #[cfg(feature = "extra-children")]
17538 {
17539 child_idx += 1;
17540 }
17541 }
17542 b"outlineViewPr" => {
17543 f_outline_view_pr = Some(Box::new(
17544 CTOutlineViewProperties::from_xml(reader, &e, false)?,
17545 ));
17546 #[cfg(feature = "extra-children")]
17547 {
17548 child_idx += 1;
17549 }
17550 }
17551 #[cfg(feature = "pml-notes")]
17552 b"notesTextViewPr" => {
17553 f_notes_text_view_pr = Some(Box::new(
17554 CTNotesTextViewProperties::from_xml(reader, &e, false)?,
17555 ));
17556 #[cfg(feature = "extra-children")]
17557 {
17558 child_idx += 1;
17559 }
17560 }
17561 b"sorterViewPr" => {
17562 f_sorter_view_pr = Some(Box::new(
17563 CTSlideSorterViewProperties::from_xml(reader, &e, false)?,
17564 ));
17565 #[cfg(feature = "extra-children")]
17566 {
17567 child_idx += 1;
17568 }
17569 }
17570 #[cfg(feature = "pml-notes")]
17571 b"notesViewPr" => {
17572 f_notes_view_pr = Some(Box::new(CTNotesViewProperties::from_xml(
17573 reader, &e, false,
17574 )?));
17575 #[cfg(feature = "extra-children")]
17576 {
17577 child_idx += 1;
17578 }
17579 }
17580 b"gridSpacing" => {
17581 f_grid_spacing = Some(Box::new(
17582 ooxml_dml::types::PositiveSize2D::from_xml(reader, &e, false)?,
17583 ));
17584 #[cfg(feature = "extra-children")]
17585 {
17586 child_idx += 1;
17587 }
17588 }
17589 #[cfg(feature = "pml-extensions")]
17590 b"extLst" => {
17591 f_ext_lst =
17592 Some(Box::new(CTExtensionList::from_xml(reader, &e, false)?));
17593 #[cfg(feature = "extra-children")]
17594 {
17595 child_idx += 1;
17596 }
17597 }
17598 #[cfg(feature = "extra-children")]
17599 _ => {
17600 let elem = RawXmlElement::from_reader(reader, &e)?;
17602 extra_children.push(PositionedNode::new(
17603 child_idx,
17604 RawXmlNode::Element(elem),
17605 ));
17606 child_idx += 1;
17607 }
17608 #[cfg(not(feature = "extra-children"))]
17609 _ => {
17610 skip_element(reader)?;
17612 }
17613 }
17614 }
17615 Event::Empty(e) => {
17616 match e.local_name().as_ref() {
17617 b"normalViewPr" => {
17618 f_normal_view_pr = Some(Box::new(
17619 CTNormalViewProperties::from_xml(reader, &e, true)?,
17620 ));
17621 #[cfg(feature = "extra-children")]
17622 {
17623 child_idx += 1;
17624 }
17625 }
17626 b"slideViewPr" => {
17627 f_slide_view_pr = Some(Box::new(CTSlideViewProperties::from_xml(
17628 reader, &e, true,
17629 )?));
17630 #[cfg(feature = "extra-children")]
17631 {
17632 child_idx += 1;
17633 }
17634 }
17635 b"outlineViewPr" => {
17636 f_outline_view_pr = Some(Box::new(
17637 CTOutlineViewProperties::from_xml(reader, &e, true)?,
17638 ));
17639 #[cfg(feature = "extra-children")]
17640 {
17641 child_idx += 1;
17642 }
17643 }
17644 #[cfg(feature = "pml-notes")]
17645 b"notesTextViewPr" => {
17646 f_notes_text_view_pr = Some(Box::new(
17647 CTNotesTextViewProperties::from_xml(reader, &e, true)?,
17648 ));
17649 #[cfg(feature = "extra-children")]
17650 {
17651 child_idx += 1;
17652 }
17653 }
17654 b"sorterViewPr" => {
17655 f_sorter_view_pr = Some(Box::new(
17656 CTSlideSorterViewProperties::from_xml(reader, &e, true)?,
17657 ));
17658 #[cfg(feature = "extra-children")]
17659 {
17660 child_idx += 1;
17661 }
17662 }
17663 #[cfg(feature = "pml-notes")]
17664 b"notesViewPr" => {
17665 f_notes_view_pr = Some(Box::new(CTNotesViewProperties::from_xml(
17666 reader, &e, true,
17667 )?));
17668 #[cfg(feature = "extra-children")]
17669 {
17670 child_idx += 1;
17671 }
17672 }
17673 b"gridSpacing" => {
17674 f_grid_spacing = Some(Box::new(
17675 ooxml_dml::types::PositiveSize2D::from_xml(reader, &e, true)?,
17676 ));
17677 #[cfg(feature = "extra-children")]
17678 {
17679 child_idx += 1;
17680 }
17681 }
17682 #[cfg(feature = "pml-extensions")]
17683 b"extLst" => {
17684 f_ext_lst =
17685 Some(Box::new(CTExtensionList::from_xml(reader, &e, true)?));
17686 #[cfg(feature = "extra-children")]
17687 {
17688 child_idx += 1;
17689 }
17690 }
17691 #[cfg(feature = "extra-children")]
17692 _ => {
17693 let elem = RawXmlElement::from_empty(&e);
17695 extra_children.push(PositionedNode::new(
17696 child_idx,
17697 RawXmlNode::Element(elem),
17698 ));
17699 child_idx += 1;
17700 }
17701 #[cfg(not(feature = "extra-children"))]
17702 _ => {}
17703 }
17704 }
17705 Event::End(_) => break,
17706 Event::Eof => break,
17707 _ => {}
17708 }
17709 buf.clear();
17710 }
17711 }
17712
17713 Ok(Self {
17714 last_view: f_last_view,
17715 #[cfg(feature = "pml-comments")]
17716 show_comments: f_show_comments,
17717 normal_view_pr: f_normal_view_pr,
17718 slide_view_pr: f_slide_view_pr,
17719 outline_view_pr: f_outline_view_pr,
17720 #[cfg(feature = "pml-notes")]
17721 notes_text_view_pr: f_notes_text_view_pr,
17722 sorter_view_pr: f_sorter_view_pr,
17723 #[cfg(feature = "pml-notes")]
17724 notes_view_pr: f_notes_view_pr,
17725 grid_spacing: f_grid_spacing,
17726 #[cfg(feature = "pml-extensions")]
17727 ext_lst: f_ext_lst,
17728 #[cfg(feature = "extra-attrs")]
17729 extra_attrs,
17730 #[cfg(feature = "extra-children")]
17731 extra_children,
17732 })
17733 }
17734}