Skip to main content

ooxml_pml/
generated_serializers.rs

1// ToXml serializers for generated types.
2// Enables roundtrip XML serialization alongside FromXml parsers.
3
4#![allow(unused_variables, unused_assignments, unreachable_code, unused_imports)]
5#![allow(clippy::single_match)]
6#![allow(clippy::match_single_binding)]
7#![allow(clippy::explicit_counter_loop)]
8
9use super::generated::*;
10use ooxml_dml::types::*;
11pub use ooxml_xml::{SerializeError, ToXml};
12use quick_xml::Writer;
13use quick_xml::events::{BytesEnd, BytesStart, BytesText, Event};
14use std::io::Write;
15
16#[allow(dead_code)]
17/// Encode bytes as a hex string.
18fn encode_hex(bytes: &[u8]) -> String {
19    bytes.iter().map(|b| format!("{:02X}", b)).collect()
20}
21
22#[allow(dead_code)]
23/// Encode bytes as a base64 string.
24fn encode_base64(bytes: &[u8]) -> String {
25    use base64::Engine;
26    base64::engine::general_purpose::STANDARD.encode(bytes)
27}
28
29impl ToXml for CTSideDirectionTransition {
30    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
31        #[allow(unused_mut)]
32        let mut start = start;
33        if let Some(ref val) = self.dir {
34            {
35                let s = val.to_string();
36                start.push_attribute(("dir", s.as_str()));
37            }
38        }
39        #[cfg(feature = "extra-attrs")]
40        for (key, value) in &self.extra_attrs {
41            start.push_attribute((key.as_str(), value.as_str()));
42        }
43        start
44    }
45
46    fn is_empty_element(&self) -> bool {
47        true
48    }
49}
50
51impl ToXml for CTCornerDirectionTransition {
52    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
53        #[allow(unused_mut)]
54        let mut start = start;
55        if let Some(ref val) = self.dir {
56            {
57                let s = val.to_string();
58                start.push_attribute(("dir", s.as_str()));
59            }
60        }
61        #[cfg(feature = "extra-attrs")]
62        for (key, value) in &self.extra_attrs {
63            start.push_attribute((key.as_str(), value.as_str()));
64        }
65        start
66    }
67
68    fn is_empty_element(&self) -> bool {
69        true
70    }
71}
72
73impl ToXml for CTEightDirectionTransition {
74    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
75        #[allow(unused_mut)]
76        let mut start = start;
77        if let Some(ref val) = self.dir {
78            {
79                let s = val.to_string();
80                start.push_attribute(("dir", s.as_str()));
81            }
82        }
83        #[cfg(feature = "extra-attrs")]
84        for (key, value) in &self.extra_attrs {
85            start.push_attribute((key.as_str(), value.as_str()));
86        }
87        start
88    }
89
90    fn is_empty_element(&self) -> bool {
91        true
92    }
93}
94
95impl ToXml for CTOrientationTransition {
96    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
97        #[allow(unused_mut)]
98        let mut start = start;
99        if let Some(ref val) = self.dir {
100            {
101                let s = val.to_string();
102                start.push_attribute(("dir", s.as_str()));
103            }
104        }
105        #[cfg(feature = "extra-attrs")]
106        for (key, value) in &self.extra_attrs {
107            start.push_attribute((key.as_str(), value.as_str()));
108        }
109        start
110    }
111
112    fn is_empty_element(&self) -> bool {
113        true
114    }
115}
116
117impl ToXml for CTInOutTransition {
118    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
119        #[allow(unused_mut)]
120        let mut start = start;
121        if let Some(ref val) = self.dir {
122            {
123                let s = val.to_string();
124                start.push_attribute(("dir", s.as_str()));
125            }
126        }
127        #[cfg(feature = "extra-attrs")]
128        for (key, value) in &self.extra_attrs {
129            start.push_attribute((key.as_str(), value.as_str()));
130        }
131        start
132    }
133
134    fn is_empty_element(&self) -> bool {
135        true
136    }
137}
138
139impl ToXml for CTOptionalBlackTransition {
140    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
141        #[allow(unused_mut)]
142        let mut start = start;
143        if let Some(ref val) = self.thru_blk {
144            start.push_attribute(("thruBlk", if *val { "1" } else { "0" }));
145        }
146        #[cfg(feature = "extra-attrs")]
147        for (key, value) in &self.extra_attrs {
148            start.push_attribute((key.as_str(), value.as_str()));
149        }
150        start
151    }
152
153    fn is_empty_element(&self) -> bool {
154        true
155    }
156}
157
158impl ToXml for CTSplitTransition {
159    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
160        #[allow(unused_mut)]
161        let mut start = start;
162        if let Some(ref val) = self.orient {
163            {
164                let s = val.to_string();
165                start.push_attribute(("orient", s.as_str()));
166            }
167        }
168        if let Some(ref val) = self.dir {
169            {
170                let s = val.to_string();
171                start.push_attribute(("dir", s.as_str()));
172            }
173        }
174        #[cfg(feature = "extra-attrs")]
175        for (key, value) in &self.extra_attrs {
176            start.push_attribute((key.as_str(), value.as_str()));
177        }
178        start
179    }
180
181    fn is_empty_element(&self) -> bool {
182        true
183    }
184}
185
186impl ToXml for CTWheelTransition {
187    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
188        #[allow(unused_mut)]
189        let mut start = start;
190        if let Some(ref val) = self.spokes {
191            {
192                let s = val.to_string();
193                start.push_attribute(("spokes", s.as_str()));
194            }
195        }
196        #[cfg(feature = "extra-attrs")]
197        for (key, value) in &self.extra_attrs {
198            start.push_attribute((key.as_str(), value.as_str()));
199        }
200        start
201    }
202
203    fn is_empty_element(&self) -> bool {
204        true
205    }
206}
207
208impl ToXml for CTTransitionStartSoundAction {
209    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
210        #[allow(unused_mut)]
211        let mut start = start;
212        if let Some(ref val) = self.r#loop {
213            start.push_attribute(("loop", if *val { "1" } else { "0" }));
214        }
215        #[cfg(feature = "extra-attrs")]
216        for (key, value) in &self.extra_attrs {
217            start.push_attribute((key.as_str(), value.as_str()));
218        }
219        start
220    }
221
222    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
223        #[cfg(feature = "extra-children")]
224        let mut extra_iter = self.extra_children.iter().peekable();
225        #[cfg(feature = "extra-children")]
226        let mut emit_idx: usize = 0;
227        #[cfg(feature = "extra-children")]
228        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
229            extra_iter
230                .next()
231                .unwrap()
232                .node
233                .write_to(writer)
234                .map_err(SerializeError::from)?;
235        }
236        {
237            let val = &self.snd;
238            val.write_element("p:snd", writer)?;
239        }
240        #[cfg(feature = "extra-children")]
241        {
242            emit_idx += 1;
243        }
244        #[cfg(feature = "extra-children")]
245        for extra in extra_iter {
246            extra.node.write_to(writer).map_err(SerializeError::from)?;
247        }
248        Ok(())
249    }
250
251    fn is_empty_element(&self) -> bool {
252        false
253    }
254}
255
256impl ToXml for CTTransitionSoundAction {
257    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
258        #[cfg(feature = "extra-children")]
259        let mut extra_iter = self.extra_children.iter().peekable();
260        #[cfg(feature = "extra-children")]
261        let mut emit_idx: usize = 0;
262        #[cfg(feature = "extra-children")]
263        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
264            extra_iter
265                .next()
266                .unwrap()
267                .node
268                .write_to(writer)
269                .map_err(SerializeError::from)?;
270        }
271        if let Some(ref val) = self.st_snd {
272            val.write_element("p:stSnd", writer)?;
273        }
274        #[cfg(feature = "extra-children")]
275        {
276            emit_idx += 1;
277        }
278        #[cfg(feature = "extra-children")]
279        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
280            extra_iter
281                .next()
282                .unwrap()
283                .node
284                .write_to(writer)
285                .map_err(SerializeError::from)?;
286        }
287        if let Some(ref val) = self.end_snd {
288            val.write_element("p:endSnd", writer)?;
289        }
290        #[cfg(feature = "extra-children")]
291        {
292            emit_idx += 1;
293        }
294        #[cfg(feature = "extra-children")]
295        for extra in extra_iter {
296            extra.node.write_to(writer).map_err(SerializeError::from)?;
297        }
298        Ok(())
299    }
300
301    fn is_empty_element(&self) -> bool {
302        if self.st_snd.is_some() {
303            return false;
304        }
305        if self.end_snd.is_some() {
306            return false;
307        }
308        #[cfg(feature = "extra-children")]
309        if !self.extra_children.is_empty() {
310            return false;
311        }
312        true
313    }
314}
315
316impl ToXml for SlideTransition {
317    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
318        #[allow(unused_mut)]
319        let mut start = start;
320        #[cfg(feature = "pml-transitions")]
321        if let Some(ref val) = self.spd {
322            {
323                let s = val.to_string();
324                start.push_attribute(("spd", s.as_str()));
325            }
326        }
327        #[cfg(feature = "pml-transitions")]
328        if let Some(ref val) = self.adv_click {
329            start.push_attribute(("advClick", if *val { "1" } else { "0" }));
330        }
331        #[cfg(feature = "pml-transitions")]
332        if let Some(ref val) = self.adv_tm {
333            {
334                let s = val.to_string();
335                start.push_attribute(("advTm", s.as_str()));
336            }
337        }
338        #[cfg(feature = "extra-attrs")]
339        for (key, value) in &self.extra_attrs {
340            start.push_attribute((key.as_str(), value.as_str()));
341        }
342        start
343    }
344
345    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
346        #[cfg(feature = "extra-children")]
347        let mut extra_iter = self.extra_children.iter().peekable();
348        #[cfg(feature = "extra-children")]
349        let mut emit_idx: usize = 0;
350        #[cfg(feature = "extra-children")]
351        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
352            extra_iter
353                .next()
354                .unwrap()
355                .node
356                .write_to(writer)
357                .map_err(SerializeError::from)?;
358        }
359        #[cfg(feature = "pml-transitions")]
360        if let Some(ref val) = self.blinds {
361            val.write_element("p:blinds", writer)?;
362        }
363        #[cfg(feature = "extra-children")]
364        {
365            emit_idx += 1;
366        }
367        #[cfg(feature = "extra-children")]
368        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
369            extra_iter
370                .next()
371                .unwrap()
372                .node
373                .write_to(writer)
374                .map_err(SerializeError::from)?;
375        }
376        #[cfg(feature = "pml-transitions")]
377        if let Some(ref val) = self.checker {
378            val.write_element("p:checker", writer)?;
379        }
380        #[cfg(feature = "extra-children")]
381        {
382            emit_idx += 1;
383        }
384        #[cfg(feature = "extra-children")]
385        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
386            extra_iter
387                .next()
388                .unwrap()
389                .node
390                .write_to(writer)
391                .map_err(SerializeError::from)?;
392        }
393        #[cfg(feature = "pml-transitions")]
394        if let Some(ref val) = self.circle {
395            val.write_element("p:circle", writer)?;
396        }
397        #[cfg(feature = "extra-children")]
398        {
399            emit_idx += 1;
400        }
401        #[cfg(feature = "extra-children")]
402        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
403            extra_iter
404                .next()
405                .unwrap()
406                .node
407                .write_to(writer)
408                .map_err(SerializeError::from)?;
409        }
410        #[cfg(feature = "pml-transitions")]
411        if let Some(ref val) = self.dissolve {
412            val.write_element("p:dissolve", writer)?;
413        }
414        #[cfg(feature = "extra-children")]
415        {
416            emit_idx += 1;
417        }
418        #[cfg(feature = "extra-children")]
419        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
420            extra_iter
421                .next()
422                .unwrap()
423                .node
424                .write_to(writer)
425                .map_err(SerializeError::from)?;
426        }
427        #[cfg(feature = "pml-transitions")]
428        if let Some(ref val) = self.comb {
429            val.write_element("p:comb", writer)?;
430        }
431        #[cfg(feature = "extra-children")]
432        {
433            emit_idx += 1;
434        }
435        #[cfg(feature = "extra-children")]
436        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
437            extra_iter
438                .next()
439                .unwrap()
440                .node
441                .write_to(writer)
442                .map_err(SerializeError::from)?;
443        }
444        #[cfg(feature = "pml-transitions")]
445        if let Some(ref val) = self.cover {
446            val.write_element("p:cover", writer)?;
447        }
448        #[cfg(feature = "extra-children")]
449        {
450            emit_idx += 1;
451        }
452        #[cfg(feature = "extra-children")]
453        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
454            extra_iter
455                .next()
456                .unwrap()
457                .node
458                .write_to(writer)
459                .map_err(SerializeError::from)?;
460        }
461        #[cfg(feature = "pml-transitions")]
462        if let Some(ref val) = self.cut {
463            val.write_element("p:cut", writer)?;
464        }
465        #[cfg(feature = "extra-children")]
466        {
467            emit_idx += 1;
468        }
469        #[cfg(feature = "extra-children")]
470        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
471            extra_iter
472                .next()
473                .unwrap()
474                .node
475                .write_to(writer)
476                .map_err(SerializeError::from)?;
477        }
478        #[cfg(feature = "pml-transitions")]
479        if let Some(ref val) = self.diamond {
480            val.write_element("p:diamond", writer)?;
481        }
482        #[cfg(feature = "extra-children")]
483        {
484            emit_idx += 1;
485        }
486        #[cfg(feature = "extra-children")]
487        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
488            extra_iter
489                .next()
490                .unwrap()
491                .node
492                .write_to(writer)
493                .map_err(SerializeError::from)?;
494        }
495        #[cfg(feature = "pml-transitions")]
496        if let Some(ref val) = self.fade {
497            val.write_element("p:fade", writer)?;
498        }
499        #[cfg(feature = "extra-children")]
500        {
501            emit_idx += 1;
502        }
503        #[cfg(feature = "extra-children")]
504        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
505            extra_iter
506                .next()
507                .unwrap()
508                .node
509                .write_to(writer)
510                .map_err(SerializeError::from)?;
511        }
512        #[cfg(feature = "pml-transitions")]
513        if let Some(ref val) = self.newsflash {
514            val.write_element("p:newsflash", writer)?;
515        }
516        #[cfg(feature = "extra-children")]
517        {
518            emit_idx += 1;
519        }
520        #[cfg(feature = "extra-children")]
521        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
522            extra_iter
523                .next()
524                .unwrap()
525                .node
526                .write_to(writer)
527                .map_err(SerializeError::from)?;
528        }
529        #[cfg(feature = "pml-transitions")]
530        if let Some(ref val) = self.plus {
531            val.write_element("p:plus", writer)?;
532        }
533        #[cfg(feature = "extra-children")]
534        {
535            emit_idx += 1;
536        }
537        #[cfg(feature = "extra-children")]
538        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
539            extra_iter
540                .next()
541                .unwrap()
542                .node
543                .write_to(writer)
544                .map_err(SerializeError::from)?;
545        }
546        #[cfg(feature = "pml-transitions")]
547        if let Some(ref val) = self.pull {
548            val.write_element("p:pull", writer)?;
549        }
550        #[cfg(feature = "extra-children")]
551        {
552            emit_idx += 1;
553        }
554        #[cfg(feature = "extra-children")]
555        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
556            extra_iter
557                .next()
558                .unwrap()
559                .node
560                .write_to(writer)
561                .map_err(SerializeError::from)?;
562        }
563        #[cfg(feature = "pml-transitions")]
564        if let Some(ref val) = self.push {
565            val.write_element("p:push", writer)?;
566        }
567        #[cfg(feature = "extra-children")]
568        {
569            emit_idx += 1;
570        }
571        #[cfg(feature = "extra-children")]
572        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
573            extra_iter
574                .next()
575                .unwrap()
576                .node
577                .write_to(writer)
578                .map_err(SerializeError::from)?;
579        }
580        #[cfg(feature = "pml-transitions")]
581        if let Some(ref val) = self.random {
582            val.write_element("p:random", writer)?;
583        }
584        #[cfg(feature = "extra-children")]
585        {
586            emit_idx += 1;
587        }
588        #[cfg(feature = "extra-children")]
589        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
590            extra_iter
591                .next()
592                .unwrap()
593                .node
594                .write_to(writer)
595                .map_err(SerializeError::from)?;
596        }
597        #[cfg(feature = "pml-transitions")]
598        if let Some(ref val) = self.random_bar {
599            val.write_element("p:randomBar", writer)?;
600        }
601        #[cfg(feature = "extra-children")]
602        {
603            emit_idx += 1;
604        }
605        #[cfg(feature = "extra-children")]
606        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
607            extra_iter
608                .next()
609                .unwrap()
610                .node
611                .write_to(writer)
612                .map_err(SerializeError::from)?;
613        }
614        #[cfg(feature = "pml-transitions")]
615        if let Some(ref val) = self.split {
616            val.write_element("p:split", writer)?;
617        }
618        #[cfg(feature = "extra-children")]
619        {
620            emit_idx += 1;
621        }
622        #[cfg(feature = "extra-children")]
623        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
624            extra_iter
625                .next()
626                .unwrap()
627                .node
628                .write_to(writer)
629                .map_err(SerializeError::from)?;
630        }
631        #[cfg(feature = "pml-transitions")]
632        if let Some(ref val) = self.strips {
633            val.write_element("p:strips", writer)?;
634        }
635        #[cfg(feature = "extra-children")]
636        {
637            emit_idx += 1;
638        }
639        #[cfg(feature = "extra-children")]
640        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
641            extra_iter
642                .next()
643                .unwrap()
644                .node
645                .write_to(writer)
646                .map_err(SerializeError::from)?;
647        }
648        #[cfg(feature = "pml-transitions")]
649        if let Some(ref val) = self.wedge {
650            val.write_element("p:wedge", writer)?;
651        }
652        #[cfg(feature = "extra-children")]
653        {
654            emit_idx += 1;
655        }
656        #[cfg(feature = "extra-children")]
657        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
658            extra_iter
659                .next()
660                .unwrap()
661                .node
662                .write_to(writer)
663                .map_err(SerializeError::from)?;
664        }
665        #[cfg(feature = "pml-transitions")]
666        if let Some(ref val) = self.wheel {
667            val.write_element("p:wheel", writer)?;
668        }
669        #[cfg(feature = "extra-children")]
670        {
671            emit_idx += 1;
672        }
673        #[cfg(feature = "extra-children")]
674        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
675            extra_iter
676                .next()
677                .unwrap()
678                .node
679                .write_to(writer)
680                .map_err(SerializeError::from)?;
681        }
682        #[cfg(feature = "pml-transitions")]
683        if let Some(ref val) = self.wipe {
684            val.write_element("p:wipe", writer)?;
685        }
686        #[cfg(feature = "extra-children")]
687        {
688            emit_idx += 1;
689        }
690        #[cfg(feature = "extra-children")]
691        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
692            extra_iter
693                .next()
694                .unwrap()
695                .node
696                .write_to(writer)
697                .map_err(SerializeError::from)?;
698        }
699        #[cfg(feature = "pml-transitions")]
700        if let Some(ref val) = self.zoom {
701            val.write_element("p:zoom", writer)?;
702        }
703        #[cfg(feature = "extra-children")]
704        {
705            emit_idx += 1;
706        }
707        #[cfg(feature = "extra-children")]
708        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
709            extra_iter
710                .next()
711                .unwrap()
712                .node
713                .write_to(writer)
714                .map_err(SerializeError::from)?;
715        }
716        #[cfg(feature = "pml-transitions")]
717        if let Some(ref val) = self.snd_ac {
718            val.write_element("p:sndAc", writer)?;
719        }
720        #[cfg(feature = "extra-children")]
721        {
722            emit_idx += 1;
723        }
724        #[cfg(feature = "extra-children")]
725        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
726            extra_iter
727                .next()
728                .unwrap()
729                .node
730                .write_to(writer)
731                .map_err(SerializeError::from)?;
732        }
733        #[cfg(feature = "pml-extensions")]
734        if let Some(ref val) = self.ext_lst {
735            val.write_element("p:extLst", writer)?;
736        }
737        #[cfg(feature = "extra-children")]
738        {
739            emit_idx += 1;
740        }
741        #[cfg(feature = "extra-children")]
742        for extra in extra_iter {
743            extra.node.write_to(writer).map_err(SerializeError::from)?;
744        }
745        Ok(())
746    }
747
748    fn is_empty_element(&self) -> bool {
749        #[cfg(feature = "pml-transitions")]
750        if self.blinds.is_some() {
751            return false;
752        }
753        #[cfg(feature = "pml-transitions")]
754        if self.checker.is_some() {
755            return false;
756        }
757        #[cfg(feature = "pml-transitions")]
758        if self.circle.is_some() {
759            return false;
760        }
761        #[cfg(feature = "pml-transitions")]
762        if self.dissolve.is_some() {
763            return false;
764        }
765        #[cfg(feature = "pml-transitions")]
766        if self.comb.is_some() {
767            return false;
768        }
769        #[cfg(feature = "pml-transitions")]
770        if self.cover.is_some() {
771            return false;
772        }
773        #[cfg(feature = "pml-transitions")]
774        if self.cut.is_some() {
775            return false;
776        }
777        #[cfg(feature = "pml-transitions")]
778        if self.diamond.is_some() {
779            return false;
780        }
781        #[cfg(feature = "pml-transitions")]
782        if self.fade.is_some() {
783            return false;
784        }
785        #[cfg(feature = "pml-transitions")]
786        if self.newsflash.is_some() {
787            return false;
788        }
789        #[cfg(feature = "pml-transitions")]
790        if self.plus.is_some() {
791            return false;
792        }
793        #[cfg(feature = "pml-transitions")]
794        if self.pull.is_some() {
795            return false;
796        }
797        #[cfg(feature = "pml-transitions")]
798        if self.push.is_some() {
799            return false;
800        }
801        #[cfg(feature = "pml-transitions")]
802        if self.random.is_some() {
803            return false;
804        }
805        #[cfg(feature = "pml-transitions")]
806        if self.random_bar.is_some() {
807            return false;
808        }
809        #[cfg(feature = "pml-transitions")]
810        if self.split.is_some() {
811            return false;
812        }
813        #[cfg(feature = "pml-transitions")]
814        if self.strips.is_some() {
815            return false;
816        }
817        #[cfg(feature = "pml-transitions")]
818        if self.wedge.is_some() {
819            return false;
820        }
821        #[cfg(feature = "pml-transitions")]
822        if self.wheel.is_some() {
823            return false;
824        }
825        #[cfg(feature = "pml-transitions")]
826        if self.wipe.is_some() {
827            return false;
828        }
829        #[cfg(feature = "pml-transitions")]
830        if self.zoom.is_some() {
831            return false;
832        }
833        #[cfg(feature = "pml-transitions")]
834        if self.snd_ac.is_some() {
835            return false;
836        }
837        #[cfg(feature = "pml-extensions")]
838        if self.ext_lst.is_some() {
839            return false;
840        }
841        #[cfg(feature = "extra-children")]
842        if !self.extra_children.is_empty() {
843            return false;
844        }
845        true
846    }
847}
848
849impl ToXml for CTTLIterateIntervalTime {
850    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
851        #[allow(unused_mut)]
852        let mut start = start;
853        {
854            let val = &self.value;
855            {
856                let s = val.to_string();
857                start.push_attribute(("val", s.as_str()));
858            }
859        }
860        #[cfg(feature = "extra-attrs")]
861        for (key, value) in &self.extra_attrs {
862            start.push_attribute((key.as_str(), value.as_str()));
863        }
864        start
865    }
866
867    fn is_empty_element(&self) -> bool {
868        true
869    }
870}
871
872impl ToXml for CTTLIterateIntervalPercentage {
873    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
874        #[allow(unused_mut)]
875        let mut start = start;
876        {
877            let val = &self.value;
878            {
879                let s = val.to_string();
880                start.push_attribute(("val", s.as_str()));
881            }
882        }
883        #[cfg(feature = "extra-attrs")]
884        for (key, value) in &self.extra_attrs {
885            start.push_attribute((key.as_str(), value.as_str()));
886        }
887        start
888    }
889
890    fn is_empty_element(&self) -> bool {
891        true
892    }
893}
894
895impl ToXml for CTTLIterateData {
896    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
897        #[allow(unused_mut)]
898        let mut start = start;
899        if let Some(ref val) = self.r#type {
900            {
901                let s = val.to_string();
902                start.push_attribute(("type", s.as_str()));
903            }
904        }
905        if let Some(ref val) = self.backwards {
906            start.push_attribute(("backwards", if *val { "1" } else { "0" }));
907        }
908        #[cfg(feature = "extra-attrs")]
909        for (key, value) in &self.extra_attrs {
910            start.push_attribute((key.as_str(), value.as_str()));
911        }
912        start
913    }
914
915    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
916        #[cfg(feature = "extra-children")]
917        let mut extra_iter = self.extra_children.iter().peekable();
918        #[cfg(feature = "extra-children")]
919        let mut emit_idx: usize = 0;
920        #[cfg(feature = "extra-children")]
921        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
922            extra_iter
923                .next()
924                .unwrap()
925                .node
926                .write_to(writer)
927                .map_err(SerializeError::from)?;
928        }
929        if let Some(ref val) = self.tm_abs {
930            val.write_element("p:tmAbs", writer)?;
931        }
932        #[cfg(feature = "extra-children")]
933        {
934            emit_idx += 1;
935        }
936        #[cfg(feature = "extra-children")]
937        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
938            extra_iter
939                .next()
940                .unwrap()
941                .node
942                .write_to(writer)
943                .map_err(SerializeError::from)?;
944        }
945        if let Some(ref val) = self.tm_pct {
946            val.write_element("p:tmPct", writer)?;
947        }
948        #[cfg(feature = "extra-children")]
949        {
950            emit_idx += 1;
951        }
952        #[cfg(feature = "extra-children")]
953        for extra in extra_iter {
954            extra.node.write_to(writer).map_err(SerializeError::from)?;
955        }
956        Ok(())
957    }
958
959    fn is_empty_element(&self) -> bool {
960        if self.tm_abs.is_some() {
961            return false;
962        }
963        if self.tm_pct.is_some() {
964            return false;
965        }
966        #[cfg(feature = "extra-children")]
967        if !self.extra_children.is_empty() {
968            return false;
969        }
970        true
971    }
972}
973
974impl ToXml for CTTLSubShapeId {
975    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
976        #[allow(unused_mut)]
977        let mut start = start;
978        {
979            let val = &self.spid;
980            {
981                let s = val.to_string();
982                start.push_attribute(("spid", s.as_str()));
983            }
984        }
985        #[cfg(feature = "extra-attrs")]
986        for (key, value) in &self.extra_attrs {
987            start.push_attribute((key.as_str(), value.as_str()));
988        }
989        start
990    }
991
992    fn is_empty_element(&self) -> bool {
993        true
994    }
995}
996
997impl ToXml for CTTLTextTargetElement {
998    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
999        #[cfg(feature = "extra-children")]
1000        let mut extra_iter = self.extra_children.iter().peekable();
1001        #[cfg(feature = "extra-children")]
1002        let mut emit_idx: usize = 0;
1003        #[cfg(feature = "extra-children")]
1004        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1005            extra_iter
1006                .next()
1007                .unwrap()
1008                .node
1009                .write_to(writer)
1010                .map_err(SerializeError::from)?;
1011        }
1012        if let Some(ref val) = self.char_rg {
1013            val.write_element("p:charRg", writer)?;
1014        }
1015        #[cfg(feature = "extra-children")]
1016        {
1017            emit_idx += 1;
1018        }
1019        #[cfg(feature = "extra-children")]
1020        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1021            extra_iter
1022                .next()
1023                .unwrap()
1024                .node
1025                .write_to(writer)
1026                .map_err(SerializeError::from)?;
1027        }
1028        if let Some(ref val) = self.p_rg {
1029            val.write_element("p:pRg", writer)?;
1030        }
1031        #[cfg(feature = "extra-children")]
1032        {
1033            emit_idx += 1;
1034        }
1035        #[cfg(feature = "extra-children")]
1036        for extra in extra_iter {
1037            extra.node.write_to(writer).map_err(SerializeError::from)?;
1038        }
1039        Ok(())
1040    }
1041
1042    fn is_empty_element(&self) -> bool {
1043        if self.char_rg.is_some() {
1044            return false;
1045        }
1046        if self.p_rg.is_some() {
1047            return false;
1048        }
1049        #[cfg(feature = "extra-children")]
1050        if !self.extra_children.is_empty() {
1051            return false;
1052        }
1053        true
1054    }
1055}
1056
1057impl ToXml for CTTLOleChartTargetElement {
1058    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
1059        #[allow(unused_mut)]
1060        let mut start = start;
1061        {
1062            let val = &self.r#type;
1063            {
1064                let s = val.to_string();
1065                start.push_attribute(("type", s.as_str()));
1066            }
1067        }
1068        if let Some(ref val) = self.lvl {
1069            {
1070                let s = val.to_string();
1071                start.push_attribute(("lvl", s.as_str()));
1072            }
1073        }
1074        #[cfg(feature = "extra-attrs")]
1075        for (key, value) in &self.extra_attrs {
1076            start.push_attribute((key.as_str(), value.as_str()));
1077        }
1078        start
1079    }
1080
1081    fn is_empty_element(&self) -> bool {
1082        true
1083    }
1084}
1085
1086impl ToXml for CTTLShapeTargetElement {
1087    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
1088        #[allow(unused_mut)]
1089        let mut start = start;
1090        {
1091            let val = &self.spid;
1092            {
1093                let s = val.to_string();
1094                start.push_attribute(("spid", s.as_str()));
1095            }
1096        }
1097        #[cfg(feature = "extra-attrs")]
1098        for (key, value) in &self.extra_attrs {
1099            start.push_attribute((key.as_str(), value.as_str()));
1100        }
1101        start
1102    }
1103
1104    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
1105        #[cfg(feature = "extra-children")]
1106        let mut extra_iter = self.extra_children.iter().peekable();
1107        #[cfg(feature = "extra-children")]
1108        let mut emit_idx: usize = 0;
1109        #[cfg(feature = "extra-children")]
1110        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1111            extra_iter
1112                .next()
1113                .unwrap()
1114                .node
1115                .write_to(writer)
1116                .map_err(SerializeError::from)?;
1117        }
1118        if let Some(ref val) = self.bg {
1119            val.write_element("p:bg", writer)?;
1120        }
1121        #[cfg(feature = "extra-children")]
1122        {
1123            emit_idx += 1;
1124        }
1125        #[cfg(feature = "extra-children")]
1126        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1127            extra_iter
1128                .next()
1129                .unwrap()
1130                .node
1131                .write_to(writer)
1132                .map_err(SerializeError::from)?;
1133        }
1134        if let Some(ref val) = self.sub_sp {
1135            val.write_element("p:subSp", writer)?;
1136        }
1137        #[cfg(feature = "extra-children")]
1138        {
1139            emit_idx += 1;
1140        }
1141        #[cfg(feature = "extra-children")]
1142        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1143            extra_iter
1144                .next()
1145                .unwrap()
1146                .node
1147                .write_to(writer)
1148                .map_err(SerializeError::from)?;
1149        }
1150        if let Some(ref val) = self.ole_chart_el {
1151            val.write_element("p:oleChartEl", writer)?;
1152        }
1153        #[cfg(feature = "extra-children")]
1154        {
1155            emit_idx += 1;
1156        }
1157        #[cfg(feature = "extra-children")]
1158        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1159            extra_iter
1160                .next()
1161                .unwrap()
1162                .node
1163                .write_to(writer)
1164                .map_err(SerializeError::from)?;
1165        }
1166        if let Some(ref val) = self.tx_el {
1167            val.write_element("p:txEl", writer)?;
1168        }
1169        #[cfg(feature = "extra-children")]
1170        {
1171            emit_idx += 1;
1172        }
1173        #[cfg(feature = "extra-children")]
1174        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1175            extra_iter
1176                .next()
1177                .unwrap()
1178                .node
1179                .write_to(writer)
1180                .map_err(SerializeError::from)?;
1181        }
1182        if let Some(ref val) = self.graphic_el {
1183            val.write_element("p:graphicEl", writer)?;
1184        }
1185        #[cfg(feature = "extra-children")]
1186        {
1187            emit_idx += 1;
1188        }
1189        #[cfg(feature = "extra-children")]
1190        for extra in extra_iter {
1191            extra.node.write_to(writer).map_err(SerializeError::from)?;
1192        }
1193        Ok(())
1194    }
1195
1196    fn is_empty_element(&self) -> bool {
1197        if self.bg.is_some() {
1198            return false;
1199        }
1200        if self.sub_sp.is_some() {
1201            return false;
1202        }
1203        if self.ole_chart_el.is_some() {
1204            return false;
1205        }
1206        if self.tx_el.is_some() {
1207            return false;
1208        }
1209        if self.graphic_el.is_some() {
1210            return false;
1211        }
1212        #[cfg(feature = "extra-children")]
1213        if !self.extra_children.is_empty() {
1214            return false;
1215        }
1216        true
1217    }
1218}
1219
1220impl ToXml for CTTLTimeTargetElement {
1221    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
1222        #[cfg(feature = "extra-children")]
1223        let mut extra_iter = self.extra_children.iter().peekable();
1224        #[cfg(feature = "extra-children")]
1225        let mut emit_idx: usize = 0;
1226        #[cfg(feature = "extra-children")]
1227        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1228            extra_iter
1229                .next()
1230                .unwrap()
1231                .node
1232                .write_to(writer)
1233                .map_err(SerializeError::from)?;
1234        }
1235        if let Some(ref val) = self.sld_tgt {
1236            val.write_element("p:sldTgt", writer)?;
1237        }
1238        #[cfg(feature = "extra-children")]
1239        {
1240            emit_idx += 1;
1241        }
1242        #[cfg(feature = "extra-children")]
1243        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1244            extra_iter
1245                .next()
1246                .unwrap()
1247                .node
1248                .write_to(writer)
1249                .map_err(SerializeError::from)?;
1250        }
1251        if let Some(ref val) = self.snd_tgt {
1252            val.write_element("p:sndTgt", writer)?;
1253        }
1254        #[cfg(feature = "extra-children")]
1255        {
1256            emit_idx += 1;
1257        }
1258        #[cfg(feature = "extra-children")]
1259        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1260            extra_iter
1261                .next()
1262                .unwrap()
1263                .node
1264                .write_to(writer)
1265                .map_err(SerializeError::from)?;
1266        }
1267        if let Some(ref val) = self.sp_tgt {
1268            val.write_element("p:spTgt", writer)?;
1269        }
1270        #[cfg(feature = "extra-children")]
1271        {
1272            emit_idx += 1;
1273        }
1274        #[cfg(feature = "extra-children")]
1275        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1276            extra_iter
1277                .next()
1278                .unwrap()
1279                .node
1280                .write_to(writer)
1281                .map_err(SerializeError::from)?;
1282        }
1283        if let Some(ref val) = self.ink_tgt {
1284            val.write_element("p:inkTgt", writer)?;
1285        }
1286        #[cfg(feature = "extra-children")]
1287        {
1288            emit_idx += 1;
1289        }
1290        #[cfg(feature = "extra-children")]
1291        for extra in extra_iter {
1292            extra.node.write_to(writer).map_err(SerializeError::from)?;
1293        }
1294        Ok(())
1295    }
1296
1297    fn is_empty_element(&self) -> bool {
1298        if self.sld_tgt.is_some() {
1299            return false;
1300        }
1301        if self.snd_tgt.is_some() {
1302            return false;
1303        }
1304        if self.sp_tgt.is_some() {
1305            return false;
1306        }
1307        if self.ink_tgt.is_some() {
1308            return false;
1309        }
1310        #[cfg(feature = "extra-children")]
1311        if !self.extra_children.is_empty() {
1312            return false;
1313        }
1314        true
1315    }
1316}
1317
1318impl ToXml for CTTLTriggerTimeNodeID {
1319    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
1320        #[allow(unused_mut)]
1321        let mut start = start;
1322        {
1323            let val = &self.value;
1324            {
1325                let s = val.to_string();
1326                start.push_attribute(("val", s.as_str()));
1327            }
1328        }
1329        #[cfg(feature = "extra-attrs")]
1330        for (key, value) in &self.extra_attrs {
1331            start.push_attribute((key.as_str(), value.as_str()));
1332        }
1333        start
1334    }
1335
1336    fn is_empty_element(&self) -> bool {
1337        true
1338    }
1339}
1340
1341impl ToXml for CTTLTriggerRuntimeNode {
1342    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
1343        #[allow(unused_mut)]
1344        let mut start = start;
1345        {
1346            let val = &self.value;
1347            {
1348                let s = val.to_string();
1349                start.push_attribute(("val", s.as_str()));
1350            }
1351        }
1352        #[cfg(feature = "extra-attrs")]
1353        for (key, value) in &self.extra_attrs {
1354            start.push_attribute((key.as_str(), value.as_str()));
1355        }
1356        start
1357    }
1358
1359    fn is_empty_element(&self) -> bool {
1360        true
1361    }
1362}
1363
1364impl ToXml for CTTLTimeCondition {
1365    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
1366        #[allow(unused_mut)]
1367        let mut start = start;
1368        if let Some(ref val) = self.evt {
1369            {
1370                let s = val.to_string();
1371                start.push_attribute(("evt", s.as_str()));
1372            }
1373        }
1374        if let Some(ref val) = self.delay {
1375            {
1376                let s = val.to_string();
1377                start.push_attribute(("delay", s.as_str()));
1378            }
1379        }
1380        #[cfg(feature = "extra-attrs")]
1381        for (key, value) in &self.extra_attrs {
1382            start.push_attribute((key.as_str(), value.as_str()));
1383        }
1384        start
1385    }
1386
1387    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
1388        #[cfg(feature = "extra-children")]
1389        let mut extra_iter = self.extra_children.iter().peekable();
1390        #[cfg(feature = "extra-children")]
1391        let mut emit_idx: usize = 0;
1392        #[cfg(feature = "extra-children")]
1393        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1394            extra_iter
1395                .next()
1396                .unwrap()
1397                .node
1398                .write_to(writer)
1399                .map_err(SerializeError::from)?;
1400        }
1401        if let Some(ref val) = self.tgt_el {
1402            val.write_element("p:tgtEl", writer)?;
1403        }
1404        #[cfg(feature = "extra-children")]
1405        {
1406            emit_idx += 1;
1407        }
1408        #[cfg(feature = "extra-children")]
1409        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1410            extra_iter
1411                .next()
1412                .unwrap()
1413                .node
1414                .write_to(writer)
1415                .map_err(SerializeError::from)?;
1416        }
1417        if let Some(ref val) = self.tn {
1418            val.write_element("p:tn", writer)?;
1419        }
1420        #[cfg(feature = "extra-children")]
1421        {
1422            emit_idx += 1;
1423        }
1424        #[cfg(feature = "extra-children")]
1425        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1426            extra_iter
1427                .next()
1428                .unwrap()
1429                .node
1430                .write_to(writer)
1431                .map_err(SerializeError::from)?;
1432        }
1433        if let Some(ref val) = self.rtn {
1434            val.write_element("p:rtn", writer)?;
1435        }
1436        #[cfg(feature = "extra-children")]
1437        {
1438            emit_idx += 1;
1439        }
1440        #[cfg(feature = "extra-children")]
1441        for extra in extra_iter {
1442            extra.node.write_to(writer).map_err(SerializeError::from)?;
1443        }
1444        Ok(())
1445    }
1446
1447    fn is_empty_element(&self) -> bool {
1448        if self.tgt_el.is_some() {
1449            return false;
1450        }
1451        if self.tn.is_some() {
1452            return false;
1453        }
1454        if self.rtn.is_some() {
1455            return false;
1456        }
1457        #[cfg(feature = "extra-children")]
1458        if !self.extra_children.is_empty() {
1459            return false;
1460        }
1461        true
1462    }
1463}
1464
1465impl ToXml for CTTLTimeConditionList {
1466    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
1467        #[cfg(feature = "extra-children")]
1468        let mut extra_iter = self.extra_children.iter().peekable();
1469        #[cfg(feature = "extra-children")]
1470        let mut emit_idx: usize = 0;
1471        for item in &self.cond {
1472            #[cfg(feature = "extra-children")]
1473            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1474                extra_iter
1475                    .next()
1476                    .unwrap()
1477                    .node
1478                    .write_to(writer)
1479                    .map_err(SerializeError::from)?;
1480            }
1481            item.write_element("p:cond", writer)?;
1482            #[cfg(feature = "extra-children")]
1483            {
1484                emit_idx += 1;
1485            }
1486        }
1487        #[cfg(feature = "extra-children")]
1488        for extra in extra_iter {
1489            extra.node.write_to(writer).map_err(SerializeError::from)?;
1490        }
1491        Ok(())
1492    }
1493
1494    fn is_empty_element(&self) -> bool {
1495        if !self.cond.is_empty() {
1496            return false;
1497        }
1498        #[cfg(feature = "extra-children")]
1499        if !self.extra_children.is_empty() {
1500            return false;
1501        }
1502        true
1503    }
1504}
1505
1506impl ToXml for CTTimeNodeList {
1507    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
1508        #[cfg(feature = "extra-children")]
1509        let mut extra_iter = self.extra_children.iter().peekable();
1510        #[cfg(feature = "extra-children")]
1511        let mut emit_idx: usize = 0;
1512        for item in &self.par {
1513            #[cfg(feature = "extra-children")]
1514            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1515                extra_iter
1516                    .next()
1517                    .unwrap()
1518                    .node
1519                    .write_to(writer)
1520                    .map_err(SerializeError::from)?;
1521            }
1522            item.write_element("p:par", writer)?;
1523            #[cfg(feature = "extra-children")]
1524            {
1525                emit_idx += 1;
1526            }
1527        }
1528        for item in &self.seq {
1529            #[cfg(feature = "extra-children")]
1530            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1531                extra_iter
1532                    .next()
1533                    .unwrap()
1534                    .node
1535                    .write_to(writer)
1536                    .map_err(SerializeError::from)?;
1537            }
1538            item.write_element("p:seq", writer)?;
1539            #[cfg(feature = "extra-children")]
1540            {
1541                emit_idx += 1;
1542            }
1543        }
1544        for item in &self.excl {
1545            #[cfg(feature = "extra-children")]
1546            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1547                extra_iter
1548                    .next()
1549                    .unwrap()
1550                    .node
1551                    .write_to(writer)
1552                    .map_err(SerializeError::from)?;
1553            }
1554            item.write_element("p:excl", writer)?;
1555            #[cfg(feature = "extra-children")]
1556            {
1557                emit_idx += 1;
1558            }
1559        }
1560        for item in &self.anim {
1561            #[cfg(feature = "extra-children")]
1562            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1563                extra_iter
1564                    .next()
1565                    .unwrap()
1566                    .node
1567                    .write_to(writer)
1568                    .map_err(SerializeError::from)?;
1569            }
1570            item.write_element("p:anim", writer)?;
1571            #[cfg(feature = "extra-children")]
1572            {
1573                emit_idx += 1;
1574            }
1575        }
1576        for item in &self.anim_clr {
1577            #[cfg(feature = "extra-children")]
1578            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1579                extra_iter
1580                    .next()
1581                    .unwrap()
1582                    .node
1583                    .write_to(writer)
1584                    .map_err(SerializeError::from)?;
1585            }
1586            item.write_element("p:animClr", writer)?;
1587            #[cfg(feature = "extra-children")]
1588            {
1589                emit_idx += 1;
1590            }
1591        }
1592        for item in &self.anim_effect {
1593            #[cfg(feature = "extra-children")]
1594            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1595                extra_iter
1596                    .next()
1597                    .unwrap()
1598                    .node
1599                    .write_to(writer)
1600                    .map_err(SerializeError::from)?;
1601            }
1602            item.write_element("p:animEffect", writer)?;
1603            #[cfg(feature = "extra-children")]
1604            {
1605                emit_idx += 1;
1606            }
1607        }
1608        for item in &self.anim_motion {
1609            #[cfg(feature = "extra-children")]
1610            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1611                extra_iter
1612                    .next()
1613                    .unwrap()
1614                    .node
1615                    .write_to(writer)
1616                    .map_err(SerializeError::from)?;
1617            }
1618            item.write_element("p:animMotion", writer)?;
1619            #[cfg(feature = "extra-children")]
1620            {
1621                emit_idx += 1;
1622            }
1623        }
1624        for item in &self.anim_rot {
1625            #[cfg(feature = "extra-children")]
1626            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1627                extra_iter
1628                    .next()
1629                    .unwrap()
1630                    .node
1631                    .write_to(writer)
1632                    .map_err(SerializeError::from)?;
1633            }
1634            item.write_element("p:animRot", writer)?;
1635            #[cfg(feature = "extra-children")]
1636            {
1637                emit_idx += 1;
1638            }
1639        }
1640        for item in &self.anim_scale {
1641            #[cfg(feature = "extra-children")]
1642            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1643                extra_iter
1644                    .next()
1645                    .unwrap()
1646                    .node
1647                    .write_to(writer)
1648                    .map_err(SerializeError::from)?;
1649            }
1650            item.write_element("p:animScale", writer)?;
1651            #[cfg(feature = "extra-children")]
1652            {
1653                emit_idx += 1;
1654            }
1655        }
1656        for item in &self.cmd {
1657            #[cfg(feature = "extra-children")]
1658            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1659                extra_iter
1660                    .next()
1661                    .unwrap()
1662                    .node
1663                    .write_to(writer)
1664                    .map_err(SerializeError::from)?;
1665            }
1666            item.write_element("p:cmd", writer)?;
1667            #[cfg(feature = "extra-children")]
1668            {
1669                emit_idx += 1;
1670            }
1671        }
1672        for item in &self.set {
1673            #[cfg(feature = "extra-children")]
1674            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1675                extra_iter
1676                    .next()
1677                    .unwrap()
1678                    .node
1679                    .write_to(writer)
1680                    .map_err(SerializeError::from)?;
1681            }
1682            item.write_element("p:set", writer)?;
1683            #[cfg(feature = "extra-children")]
1684            {
1685                emit_idx += 1;
1686            }
1687        }
1688        for item in &self.audio {
1689            #[cfg(feature = "extra-children")]
1690            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1691                extra_iter
1692                    .next()
1693                    .unwrap()
1694                    .node
1695                    .write_to(writer)
1696                    .map_err(SerializeError::from)?;
1697            }
1698            item.write_element("p:audio", writer)?;
1699            #[cfg(feature = "extra-children")]
1700            {
1701                emit_idx += 1;
1702            }
1703        }
1704        for item in &self.video {
1705            #[cfg(feature = "extra-children")]
1706            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1707                extra_iter
1708                    .next()
1709                    .unwrap()
1710                    .node
1711                    .write_to(writer)
1712                    .map_err(SerializeError::from)?;
1713            }
1714            item.write_element("p:video", writer)?;
1715            #[cfg(feature = "extra-children")]
1716            {
1717                emit_idx += 1;
1718            }
1719        }
1720        #[cfg(feature = "extra-children")]
1721        for extra in extra_iter {
1722            extra.node.write_to(writer).map_err(SerializeError::from)?;
1723        }
1724        Ok(())
1725    }
1726
1727    fn is_empty_element(&self) -> bool {
1728        if !self.par.is_empty() {
1729            return false;
1730        }
1731        if !self.seq.is_empty() {
1732            return false;
1733        }
1734        if !self.excl.is_empty() {
1735            return false;
1736        }
1737        if !self.anim.is_empty() {
1738            return false;
1739        }
1740        if !self.anim_clr.is_empty() {
1741            return false;
1742        }
1743        if !self.anim_effect.is_empty() {
1744            return false;
1745        }
1746        if !self.anim_motion.is_empty() {
1747            return false;
1748        }
1749        if !self.anim_rot.is_empty() {
1750            return false;
1751        }
1752        if !self.anim_scale.is_empty() {
1753            return false;
1754        }
1755        if !self.cmd.is_empty() {
1756            return false;
1757        }
1758        if !self.set.is_empty() {
1759            return false;
1760        }
1761        if !self.audio.is_empty() {
1762            return false;
1763        }
1764        if !self.video.is_empty() {
1765            return false;
1766        }
1767        #[cfg(feature = "extra-children")]
1768        if !self.extra_children.is_empty() {
1769            return false;
1770        }
1771        true
1772    }
1773}
1774
1775impl ToXml for CTTLCommonTimeNodeData {
1776    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
1777        #[allow(unused_mut)]
1778        let mut start = start;
1779        if let Some(ref val) = self.id {
1780            {
1781                let s = val.to_string();
1782                start.push_attribute(("id", s.as_str()));
1783            }
1784        }
1785        if let Some(ref val) = self.preset_i_d {
1786            {
1787                let s = val.to_string();
1788                start.push_attribute(("presetID", s.as_str()));
1789            }
1790        }
1791        if let Some(ref val) = self.preset_class {
1792            {
1793                let s = val.to_string();
1794                start.push_attribute(("presetClass", s.as_str()));
1795            }
1796        }
1797        if let Some(ref val) = self.preset_subtype {
1798            {
1799                let s = val.to_string();
1800                start.push_attribute(("presetSubtype", s.as_str()));
1801            }
1802        }
1803        if let Some(ref val) = self.dur {
1804            {
1805                let s = val.to_string();
1806                start.push_attribute(("dur", s.as_str()));
1807            }
1808        }
1809        if let Some(ref val) = self.repeat_count {
1810            {
1811                let s = val.to_string();
1812                start.push_attribute(("repeatCount", s.as_str()));
1813            }
1814        }
1815        if let Some(ref val) = self.repeat_dur {
1816            {
1817                let s = val.to_string();
1818                start.push_attribute(("repeatDur", s.as_str()));
1819            }
1820        }
1821        if let Some(ref val) = self.spd {
1822            {
1823                let s = val.to_string();
1824                start.push_attribute(("spd", s.as_str()));
1825            }
1826        }
1827        if let Some(ref val) = self.accel {
1828            {
1829                let s = val.to_string();
1830                start.push_attribute(("accel", s.as_str()));
1831            }
1832        }
1833        if let Some(ref val) = self.decel {
1834            {
1835                let s = val.to_string();
1836                start.push_attribute(("decel", s.as_str()));
1837            }
1838        }
1839        if let Some(ref val) = self.auto_rev {
1840            start.push_attribute(("autoRev", if *val { "1" } else { "0" }));
1841        }
1842        if let Some(ref val) = self.restart {
1843            {
1844                let s = val.to_string();
1845                start.push_attribute(("restart", s.as_str()));
1846            }
1847        }
1848        if let Some(ref val) = self.fill {
1849            {
1850                let s = val.to_string();
1851                start.push_attribute(("fill", s.as_str()));
1852            }
1853        }
1854        if let Some(ref val) = self.sync_behavior {
1855            {
1856                let s = val.to_string();
1857                start.push_attribute(("syncBehavior", s.as_str()));
1858            }
1859        }
1860        if let Some(ref val) = self.tm_filter {
1861            start.push_attribute(("tmFilter", val.as_str()));
1862        }
1863        if let Some(ref val) = self.evt_filter {
1864            start.push_attribute(("evtFilter", val.as_str()));
1865        }
1866        if let Some(ref val) = self.display {
1867            start.push_attribute(("display", if *val { "1" } else { "0" }));
1868        }
1869        if let Some(ref val) = self.master_rel {
1870            {
1871                let s = val.to_string();
1872                start.push_attribute(("masterRel", s.as_str()));
1873            }
1874        }
1875        if let Some(ref val) = self.bld_lvl {
1876            {
1877                let s = val.to_string();
1878                start.push_attribute(("bldLvl", s.as_str()));
1879            }
1880        }
1881        if let Some(ref val) = self.grp_id {
1882            {
1883                let s = val.to_string();
1884                start.push_attribute(("grpId", s.as_str()));
1885            }
1886        }
1887        if let Some(ref val) = self.after_effect {
1888            start.push_attribute(("afterEffect", if *val { "1" } else { "0" }));
1889        }
1890        if let Some(ref val) = self.node_type {
1891            {
1892                let s = val.to_string();
1893                start.push_attribute(("nodeType", s.as_str()));
1894            }
1895        }
1896        if let Some(ref val) = self.node_ph {
1897            start.push_attribute(("nodePh", if *val { "1" } else { "0" }));
1898        }
1899        #[cfg(feature = "extra-attrs")]
1900        for (key, value) in &self.extra_attrs {
1901            start.push_attribute((key.as_str(), value.as_str()));
1902        }
1903        start
1904    }
1905
1906    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
1907        #[cfg(feature = "extra-children")]
1908        let mut extra_iter = self.extra_children.iter().peekable();
1909        #[cfg(feature = "extra-children")]
1910        let mut emit_idx: usize = 0;
1911        #[cfg(feature = "extra-children")]
1912        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1913            extra_iter
1914                .next()
1915                .unwrap()
1916                .node
1917                .write_to(writer)
1918                .map_err(SerializeError::from)?;
1919        }
1920        if let Some(ref val) = self.st_cond_lst {
1921            val.write_element("p:stCondLst", writer)?;
1922        }
1923        #[cfg(feature = "extra-children")]
1924        {
1925            emit_idx += 1;
1926        }
1927        #[cfg(feature = "extra-children")]
1928        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1929            extra_iter
1930                .next()
1931                .unwrap()
1932                .node
1933                .write_to(writer)
1934                .map_err(SerializeError::from)?;
1935        }
1936        if let Some(ref val) = self.end_cond_lst {
1937            val.write_element("p:endCondLst", writer)?;
1938        }
1939        #[cfg(feature = "extra-children")]
1940        {
1941            emit_idx += 1;
1942        }
1943        #[cfg(feature = "extra-children")]
1944        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1945            extra_iter
1946                .next()
1947                .unwrap()
1948                .node
1949                .write_to(writer)
1950                .map_err(SerializeError::from)?;
1951        }
1952        if let Some(ref val) = self.end_sync {
1953            val.write_element("p:endSync", writer)?;
1954        }
1955        #[cfg(feature = "extra-children")]
1956        {
1957            emit_idx += 1;
1958        }
1959        #[cfg(feature = "extra-children")]
1960        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1961            extra_iter
1962                .next()
1963                .unwrap()
1964                .node
1965                .write_to(writer)
1966                .map_err(SerializeError::from)?;
1967        }
1968        if let Some(ref val) = self.iterate {
1969            val.write_element("p:iterate", writer)?;
1970        }
1971        #[cfg(feature = "extra-children")]
1972        {
1973            emit_idx += 1;
1974        }
1975        #[cfg(feature = "extra-children")]
1976        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1977            extra_iter
1978                .next()
1979                .unwrap()
1980                .node
1981                .write_to(writer)
1982                .map_err(SerializeError::from)?;
1983        }
1984        if let Some(ref val) = self.child_tn_lst {
1985            val.write_element("p:childTnLst", writer)?;
1986        }
1987        #[cfg(feature = "extra-children")]
1988        {
1989            emit_idx += 1;
1990        }
1991        #[cfg(feature = "extra-children")]
1992        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
1993            extra_iter
1994                .next()
1995                .unwrap()
1996                .node
1997                .write_to(writer)
1998                .map_err(SerializeError::from)?;
1999        }
2000        if let Some(ref val) = self.sub_tn_lst {
2001            val.write_element("p:subTnLst", writer)?;
2002        }
2003        #[cfg(feature = "extra-children")]
2004        {
2005            emit_idx += 1;
2006        }
2007        #[cfg(feature = "extra-children")]
2008        for extra in extra_iter {
2009            extra.node.write_to(writer).map_err(SerializeError::from)?;
2010        }
2011        Ok(())
2012    }
2013
2014    fn is_empty_element(&self) -> bool {
2015        if self.st_cond_lst.is_some() {
2016            return false;
2017        }
2018        if self.end_cond_lst.is_some() {
2019            return false;
2020        }
2021        if self.end_sync.is_some() {
2022            return false;
2023        }
2024        if self.iterate.is_some() {
2025            return false;
2026        }
2027        if self.child_tn_lst.is_some() {
2028            return false;
2029        }
2030        if self.sub_tn_lst.is_some() {
2031            return false;
2032        }
2033        #[cfg(feature = "extra-children")]
2034        if !self.extra_children.is_empty() {
2035            return false;
2036        }
2037        true
2038    }
2039}
2040
2041impl ToXml for CTTLTimeNodeSequence {
2042    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
2043        #[allow(unused_mut)]
2044        let mut start = start;
2045        if let Some(ref val) = self.concurrent {
2046            start.push_attribute(("concurrent", if *val { "1" } else { "0" }));
2047        }
2048        if let Some(ref val) = self.prev_ac {
2049            {
2050                let s = val.to_string();
2051                start.push_attribute(("prevAc", s.as_str()));
2052            }
2053        }
2054        if let Some(ref val) = self.next_ac {
2055            {
2056                let s = val.to_string();
2057                start.push_attribute(("nextAc", s.as_str()));
2058            }
2059        }
2060        #[cfg(feature = "extra-attrs")]
2061        for (key, value) in &self.extra_attrs {
2062            start.push_attribute((key.as_str(), value.as_str()));
2063        }
2064        start
2065    }
2066
2067    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
2068        #[cfg(feature = "extra-children")]
2069        let mut extra_iter = self.extra_children.iter().peekable();
2070        #[cfg(feature = "extra-children")]
2071        let mut emit_idx: usize = 0;
2072        #[cfg(feature = "extra-children")]
2073        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2074            extra_iter
2075                .next()
2076                .unwrap()
2077                .node
2078                .write_to(writer)
2079                .map_err(SerializeError::from)?;
2080        }
2081        {
2082            let val = &self.c_tn;
2083            val.write_element("p:cTn", writer)?;
2084        }
2085        #[cfg(feature = "extra-children")]
2086        {
2087            emit_idx += 1;
2088        }
2089        #[cfg(feature = "extra-children")]
2090        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2091            extra_iter
2092                .next()
2093                .unwrap()
2094                .node
2095                .write_to(writer)
2096                .map_err(SerializeError::from)?;
2097        }
2098        if let Some(ref val) = self.prev_cond_lst {
2099            val.write_element("p:prevCondLst", writer)?;
2100        }
2101        #[cfg(feature = "extra-children")]
2102        {
2103            emit_idx += 1;
2104        }
2105        #[cfg(feature = "extra-children")]
2106        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2107            extra_iter
2108                .next()
2109                .unwrap()
2110                .node
2111                .write_to(writer)
2112                .map_err(SerializeError::from)?;
2113        }
2114        if let Some(ref val) = self.next_cond_lst {
2115            val.write_element("p:nextCondLst", writer)?;
2116        }
2117        #[cfg(feature = "extra-children")]
2118        {
2119            emit_idx += 1;
2120        }
2121        #[cfg(feature = "extra-children")]
2122        for extra in extra_iter {
2123            extra.node.write_to(writer).map_err(SerializeError::from)?;
2124        }
2125        Ok(())
2126    }
2127
2128    fn is_empty_element(&self) -> bool {
2129        false
2130    }
2131}
2132
2133impl ToXml for CTTLBehaviorAttributeNameList {
2134    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
2135        #[cfg(feature = "extra-children")]
2136        let mut extra_iter = self.extra_children.iter().peekable();
2137        #[cfg(feature = "extra-children")]
2138        let mut emit_idx: usize = 0;
2139        for item in &self.attr_name {
2140            #[cfg(feature = "extra-children")]
2141            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2142                extra_iter
2143                    .next()
2144                    .unwrap()
2145                    .node
2146                    .write_to(writer)
2147                    .map_err(SerializeError::from)?;
2148            }
2149            {
2150                let start = BytesStart::new("p:attrName");
2151                writer.write_event(Event::Start(start))?;
2152                writer.write_event(Event::Text(BytesText::new(item.as_str())))?;
2153                writer.write_event(Event::End(BytesEnd::new("p:attrName")))?;
2154            }
2155            #[cfg(feature = "extra-children")]
2156            {
2157                emit_idx += 1;
2158            }
2159        }
2160        #[cfg(feature = "extra-children")]
2161        for extra in extra_iter {
2162            extra.node.write_to(writer).map_err(SerializeError::from)?;
2163        }
2164        Ok(())
2165    }
2166
2167    fn is_empty_element(&self) -> bool {
2168        if !self.attr_name.is_empty() {
2169            return false;
2170        }
2171        #[cfg(feature = "extra-children")]
2172        if !self.extra_children.is_empty() {
2173            return false;
2174        }
2175        true
2176    }
2177}
2178
2179impl ToXml for CTTLCommonBehaviorData {
2180    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
2181        #[allow(unused_mut)]
2182        let mut start = start;
2183        if let Some(ref val) = self.additive {
2184            {
2185                let s = val.to_string();
2186                start.push_attribute(("additive", s.as_str()));
2187            }
2188        }
2189        if let Some(ref val) = self.accumulate {
2190            {
2191                let s = val.to_string();
2192                start.push_attribute(("accumulate", s.as_str()));
2193            }
2194        }
2195        if let Some(ref val) = self.xfrm_type {
2196            {
2197                let s = val.to_string();
2198                start.push_attribute(("xfrmType", s.as_str()));
2199            }
2200        }
2201        if let Some(ref val) = self.from {
2202            start.push_attribute(("from", val.as_str()));
2203        }
2204        if let Some(ref val) = self.to {
2205            start.push_attribute(("to", val.as_str()));
2206        }
2207        if let Some(ref val) = self.by {
2208            start.push_attribute(("by", val.as_str()));
2209        }
2210        if let Some(ref val) = self.rctx {
2211            start.push_attribute(("rctx", val.as_str()));
2212        }
2213        if let Some(ref val) = self.r#override {
2214            {
2215                let s = val.to_string();
2216                start.push_attribute(("override", s.as_str()));
2217            }
2218        }
2219        #[cfg(feature = "extra-attrs")]
2220        for (key, value) in &self.extra_attrs {
2221            start.push_attribute((key.as_str(), value.as_str()));
2222        }
2223        start
2224    }
2225
2226    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
2227        #[cfg(feature = "extra-children")]
2228        let mut extra_iter = self.extra_children.iter().peekable();
2229        #[cfg(feature = "extra-children")]
2230        let mut emit_idx: usize = 0;
2231        #[cfg(feature = "extra-children")]
2232        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2233            extra_iter
2234                .next()
2235                .unwrap()
2236                .node
2237                .write_to(writer)
2238                .map_err(SerializeError::from)?;
2239        }
2240        {
2241            let val = &self.c_tn;
2242            val.write_element("p:cTn", writer)?;
2243        }
2244        #[cfg(feature = "extra-children")]
2245        {
2246            emit_idx += 1;
2247        }
2248        #[cfg(feature = "extra-children")]
2249        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2250            extra_iter
2251                .next()
2252                .unwrap()
2253                .node
2254                .write_to(writer)
2255                .map_err(SerializeError::from)?;
2256        }
2257        {
2258            let val = &self.tgt_el;
2259            val.write_element("p:tgtEl", writer)?;
2260        }
2261        #[cfg(feature = "extra-children")]
2262        {
2263            emit_idx += 1;
2264        }
2265        #[cfg(feature = "extra-children")]
2266        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2267            extra_iter
2268                .next()
2269                .unwrap()
2270                .node
2271                .write_to(writer)
2272                .map_err(SerializeError::from)?;
2273        }
2274        if let Some(ref val) = self.attr_name_lst {
2275            val.write_element("p:attrNameLst", writer)?;
2276        }
2277        #[cfg(feature = "extra-children")]
2278        {
2279            emit_idx += 1;
2280        }
2281        #[cfg(feature = "extra-children")]
2282        for extra in extra_iter {
2283            extra.node.write_to(writer).map_err(SerializeError::from)?;
2284        }
2285        Ok(())
2286    }
2287
2288    fn is_empty_element(&self) -> bool {
2289        false
2290    }
2291}
2292
2293impl ToXml for CTTLAnimVariantBooleanVal {
2294    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
2295        #[allow(unused_mut)]
2296        let mut start = start;
2297        {
2298            let val = &self.value;
2299            start.push_attribute(("val", if *val { "1" } else { "0" }));
2300        }
2301        #[cfg(feature = "extra-attrs")]
2302        for (key, value) in &self.extra_attrs {
2303            start.push_attribute((key.as_str(), value.as_str()));
2304        }
2305        start
2306    }
2307
2308    fn is_empty_element(&self) -> bool {
2309        true
2310    }
2311}
2312
2313impl ToXml for CTTLAnimVariantIntegerVal {
2314    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
2315        #[allow(unused_mut)]
2316        let mut start = start;
2317        {
2318            let val = &self.value;
2319            {
2320                let s = val.to_string();
2321                start.push_attribute(("val", s.as_str()));
2322            }
2323        }
2324        #[cfg(feature = "extra-attrs")]
2325        for (key, value) in &self.extra_attrs {
2326            start.push_attribute((key.as_str(), value.as_str()));
2327        }
2328        start
2329    }
2330
2331    fn is_empty_element(&self) -> bool {
2332        true
2333    }
2334}
2335
2336impl ToXml for CTTLAnimVariantFloatVal {
2337    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
2338        #[allow(unused_mut)]
2339        let mut start = start;
2340        {
2341            let val = &self.value;
2342            {
2343                let s = val.to_string();
2344                start.push_attribute(("val", s.as_str()));
2345            }
2346        }
2347        #[cfg(feature = "extra-attrs")]
2348        for (key, value) in &self.extra_attrs {
2349            start.push_attribute((key.as_str(), value.as_str()));
2350        }
2351        start
2352    }
2353
2354    fn is_empty_element(&self) -> bool {
2355        true
2356    }
2357}
2358
2359impl ToXml for CTTLAnimVariantStringVal {
2360    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
2361        #[allow(unused_mut)]
2362        let mut start = start;
2363        {
2364            let val = &self.value;
2365            start.push_attribute(("val", val.as_str()));
2366        }
2367        #[cfg(feature = "extra-attrs")]
2368        for (key, value) in &self.extra_attrs {
2369            start.push_attribute((key.as_str(), value.as_str()));
2370        }
2371        start
2372    }
2373
2374    fn is_empty_element(&self) -> bool {
2375        true
2376    }
2377}
2378
2379impl ToXml for CTTLAnimVariant {
2380    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
2381        #[cfg(feature = "extra-children")]
2382        let mut extra_iter = self.extra_children.iter().peekable();
2383        #[cfg(feature = "extra-children")]
2384        let mut emit_idx: usize = 0;
2385        #[cfg(feature = "extra-children")]
2386        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2387            extra_iter
2388                .next()
2389                .unwrap()
2390                .node
2391                .write_to(writer)
2392                .map_err(SerializeError::from)?;
2393        }
2394        if let Some(ref val) = self.bool_val {
2395            val.write_element("p:boolVal", writer)?;
2396        }
2397        #[cfg(feature = "extra-children")]
2398        {
2399            emit_idx += 1;
2400        }
2401        #[cfg(feature = "extra-children")]
2402        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2403            extra_iter
2404                .next()
2405                .unwrap()
2406                .node
2407                .write_to(writer)
2408                .map_err(SerializeError::from)?;
2409        }
2410        if let Some(ref val) = self.int_val {
2411            val.write_element("p:intVal", writer)?;
2412        }
2413        #[cfg(feature = "extra-children")]
2414        {
2415            emit_idx += 1;
2416        }
2417        #[cfg(feature = "extra-children")]
2418        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2419            extra_iter
2420                .next()
2421                .unwrap()
2422                .node
2423                .write_to(writer)
2424                .map_err(SerializeError::from)?;
2425        }
2426        if let Some(ref val) = self.flt_val {
2427            val.write_element("p:fltVal", writer)?;
2428        }
2429        #[cfg(feature = "extra-children")]
2430        {
2431            emit_idx += 1;
2432        }
2433        #[cfg(feature = "extra-children")]
2434        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2435            extra_iter
2436                .next()
2437                .unwrap()
2438                .node
2439                .write_to(writer)
2440                .map_err(SerializeError::from)?;
2441        }
2442        if let Some(ref val) = self.str_val {
2443            val.write_element("p:strVal", writer)?;
2444        }
2445        #[cfg(feature = "extra-children")]
2446        {
2447            emit_idx += 1;
2448        }
2449        #[cfg(feature = "extra-children")]
2450        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2451            extra_iter
2452                .next()
2453                .unwrap()
2454                .node
2455                .write_to(writer)
2456                .map_err(SerializeError::from)?;
2457        }
2458        if let Some(ref val) = self.clr_val {
2459            val.write_element("p:clrVal", writer)?;
2460        }
2461        #[cfg(feature = "extra-children")]
2462        {
2463            emit_idx += 1;
2464        }
2465        #[cfg(feature = "extra-children")]
2466        for extra in extra_iter {
2467            extra.node.write_to(writer).map_err(SerializeError::from)?;
2468        }
2469        Ok(())
2470    }
2471
2472    fn is_empty_element(&self) -> bool {
2473        if self.bool_val.is_some() {
2474            return false;
2475        }
2476        if self.int_val.is_some() {
2477            return false;
2478        }
2479        if self.flt_val.is_some() {
2480            return false;
2481        }
2482        if self.str_val.is_some() {
2483            return false;
2484        }
2485        if self.clr_val.is_some() {
2486            return false;
2487        }
2488        #[cfg(feature = "extra-children")]
2489        if !self.extra_children.is_empty() {
2490            return false;
2491        }
2492        true
2493    }
2494}
2495
2496impl ToXml for CTTLTimeAnimateValue {
2497    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
2498        #[allow(unused_mut)]
2499        let mut start = start;
2500        if let Some(ref val) = self.tm {
2501            {
2502                let s = val.to_string();
2503                start.push_attribute(("tm", s.as_str()));
2504            }
2505        }
2506        if let Some(ref val) = self.fmla {
2507            start.push_attribute(("fmla", val.as_str()));
2508        }
2509        #[cfg(feature = "extra-attrs")]
2510        for (key, value) in &self.extra_attrs {
2511            start.push_attribute((key.as_str(), value.as_str()));
2512        }
2513        start
2514    }
2515
2516    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
2517        #[cfg(feature = "extra-children")]
2518        let mut extra_iter = self.extra_children.iter().peekable();
2519        #[cfg(feature = "extra-children")]
2520        let mut emit_idx: usize = 0;
2521        #[cfg(feature = "extra-children")]
2522        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2523            extra_iter
2524                .next()
2525                .unwrap()
2526                .node
2527                .write_to(writer)
2528                .map_err(SerializeError::from)?;
2529        }
2530        if let Some(ref val) = self.value {
2531            val.write_element("p:val", writer)?;
2532        }
2533        #[cfg(feature = "extra-children")]
2534        {
2535            emit_idx += 1;
2536        }
2537        #[cfg(feature = "extra-children")]
2538        for extra in extra_iter {
2539            extra.node.write_to(writer).map_err(SerializeError::from)?;
2540        }
2541        Ok(())
2542    }
2543
2544    fn is_empty_element(&self) -> bool {
2545        if self.value.is_some() {
2546            return false;
2547        }
2548        #[cfg(feature = "extra-children")]
2549        if !self.extra_children.is_empty() {
2550            return false;
2551        }
2552        true
2553    }
2554}
2555
2556impl ToXml for CTTLTimeAnimateValueList {
2557    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
2558        #[cfg(feature = "extra-children")]
2559        let mut extra_iter = self.extra_children.iter().peekable();
2560        #[cfg(feature = "extra-children")]
2561        let mut emit_idx: usize = 0;
2562        for item in &self.tav {
2563            #[cfg(feature = "extra-children")]
2564            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2565                extra_iter
2566                    .next()
2567                    .unwrap()
2568                    .node
2569                    .write_to(writer)
2570                    .map_err(SerializeError::from)?;
2571            }
2572            item.write_element("p:tav", writer)?;
2573            #[cfg(feature = "extra-children")]
2574            {
2575                emit_idx += 1;
2576            }
2577        }
2578        #[cfg(feature = "extra-children")]
2579        for extra in extra_iter {
2580            extra.node.write_to(writer).map_err(SerializeError::from)?;
2581        }
2582        Ok(())
2583    }
2584
2585    fn is_empty_element(&self) -> bool {
2586        if !self.tav.is_empty() {
2587            return false;
2588        }
2589        #[cfg(feature = "extra-children")]
2590        if !self.extra_children.is_empty() {
2591            return false;
2592        }
2593        true
2594    }
2595}
2596
2597impl ToXml for CTTLAnimateBehavior {
2598    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
2599        #[allow(unused_mut)]
2600        let mut start = start;
2601        if let Some(ref val) = self.by {
2602            start.push_attribute(("by", val.as_str()));
2603        }
2604        if let Some(ref val) = self.from {
2605            start.push_attribute(("from", val.as_str()));
2606        }
2607        if let Some(ref val) = self.to {
2608            start.push_attribute(("to", val.as_str()));
2609        }
2610        if let Some(ref val) = self.calcmode {
2611            {
2612                let s = val.to_string();
2613                start.push_attribute(("calcmode", s.as_str()));
2614            }
2615        }
2616        if let Some(ref val) = self.value_type {
2617            {
2618                let s = val.to_string();
2619                start.push_attribute(("valueType", s.as_str()));
2620            }
2621        }
2622        #[cfg(feature = "extra-attrs")]
2623        for (key, value) in &self.extra_attrs {
2624            start.push_attribute((key.as_str(), value.as_str()));
2625        }
2626        start
2627    }
2628
2629    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
2630        #[cfg(feature = "extra-children")]
2631        let mut extra_iter = self.extra_children.iter().peekable();
2632        #[cfg(feature = "extra-children")]
2633        let mut emit_idx: usize = 0;
2634        #[cfg(feature = "extra-children")]
2635        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2636            extra_iter
2637                .next()
2638                .unwrap()
2639                .node
2640                .write_to(writer)
2641                .map_err(SerializeError::from)?;
2642        }
2643        {
2644            let val = &self.c_bhvr;
2645            val.write_element("p:cBhvr", writer)?;
2646        }
2647        #[cfg(feature = "extra-children")]
2648        {
2649            emit_idx += 1;
2650        }
2651        #[cfg(feature = "extra-children")]
2652        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2653            extra_iter
2654                .next()
2655                .unwrap()
2656                .node
2657                .write_to(writer)
2658                .map_err(SerializeError::from)?;
2659        }
2660        if let Some(ref val) = self.tav_lst {
2661            val.write_element("p:tavLst", writer)?;
2662        }
2663        #[cfg(feature = "extra-children")]
2664        {
2665            emit_idx += 1;
2666        }
2667        #[cfg(feature = "extra-children")]
2668        for extra in extra_iter {
2669            extra.node.write_to(writer).map_err(SerializeError::from)?;
2670        }
2671        Ok(())
2672    }
2673
2674    fn is_empty_element(&self) -> bool {
2675        false
2676    }
2677}
2678
2679impl ToXml for CTTLByRgbColorTransform {
2680    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
2681        #[allow(unused_mut)]
2682        let mut start = start;
2683        {
2684            let val = &self.reference;
2685            {
2686                let s = val.to_string();
2687                start.push_attribute(("r", s.as_str()));
2688            }
2689        }
2690        {
2691            let val = &self.g;
2692            {
2693                let s = val.to_string();
2694                start.push_attribute(("g", s.as_str()));
2695            }
2696        }
2697        {
2698            let val = &self.b;
2699            {
2700                let s = val.to_string();
2701                start.push_attribute(("b", s.as_str()));
2702            }
2703        }
2704        #[cfg(feature = "extra-attrs")]
2705        for (key, value) in &self.extra_attrs {
2706            start.push_attribute((key.as_str(), value.as_str()));
2707        }
2708        start
2709    }
2710
2711    fn is_empty_element(&self) -> bool {
2712        true
2713    }
2714}
2715
2716impl ToXml for CTTLByHslColorTransform {
2717    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
2718        #[allow(unused_mut)]
2719        let mut start = start;
2720        {
2721            let val = &self.height;
2722            {
2723                let s = val.to_string();
2724                start.push_attribute(("h", s.as_str()));
2725            }
2726        }
2727        {
2728            let val = &self.s;
2729            {
2730                let s = val.to_string();
2731                start.push_attribute(("s", s.as_str()));
2732            }
2733        }
2734        {
2735            let val = &self.l;
2736            {
2737                let s = val.to_string();
2738                start.push_attribute(("l", s.as_str()));
2739            }
2740        }
2741        #[cfg(feature = "extra-attrs")]
2742        for (key, value) in &self.extra_attrs {
2743            start.push_attribute((key.as_str(), value.as_str()));
2744        }
2745        start
2746    }
2747
2748    fn is_empty_element(&self) -> bool {
2749        true
2750    }
2751}
2752
2753impl ToXml for CTTLByAnimateColorTransform {
2754    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
2755        #[cfg(feature = "extra-children")]
2756        let mut extra_iter = self.extra_children.iter().peekable();
2757        #[cfg(feature = "extra-children")]
2758        let mut emit_idx: usize = 0;
2759        #[cfg(feature = "extra-children")]
2760        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2761            extra_iter
2762                .next()
2763                .unwrap()
2764                .node
2765                .write_to(writer)
2766                .map_err(SerializeError::from)?;
2767        }
2768        if let Some(ref val) = self.rgb {
2769            val.write_element("p:rgb", writer)?;
2770        }
2771        #[cfg(feature = "extra-children")]
2772        {
2773            emit_idx += 1;
2774        }
2775        #[cfg(feature = "extra-children")]
2776        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2777            extra_iter
2778                .next()
2779                .unwrap()
2780                .node
2781                .write_to(writer)
2782                .map_err(SerializeError::from)?;
2783        }
2784        if let Some(ref val) = self.hsl {
2785            val.write_element("p:hsl", writer)?;
2786        }
2787        #[cfg(feature = "extra-children")]
2788        {
2789            emit_idx += 1;
2790        }
2791        #[cfg(feature = "extra-children")]
2792        for extra in extra_iter {
2793            extra.node.write_to(writer).map_err(SerializeError::from)?;
2794        }
2795        Ok(())
2796    }
2797
2798    fn is_empty_element(&self) -> bool {
2799        if self.rgb.is_some() {
2800            return false;
2801        }
2802        if self.hsl.is_some() {
2803            return false;
2804        }
2805        #[cfg(feature = "extra-children")]
2806        if !self.extra_children.is_empty() {
2807            return false;
2808        }
2809        true
2810    }
2811}
2812
2813impl ToXml for CTTLAnimateColorBehavior {
2814    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
2815        #[allow(unused_mut)]
2816        let mut start = start;
2817        if let Some(ref val) = self.clr_spc {
2818            {
2819                let s = val.to_string();
2820                start.push_attribute(("clrSpc", s.as_str()));
2821            }
2822        }
2823        if let Some(ref val) = self.dir {
2824            {
2825                let s = val.to_string();
2826                start.push_attribute(("dir", s.as_str()));
2827            }
2828        }
2829        #[cfg(feature = "extra-attrs")]
2830        for (key, value) in &self.extra_attrs {
2831            start.push_attribute((key.as_str(), value.as_str()));
2832        }
2833        start
2834    }
2835
2836    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
2837        #[cfg(feature = "extra-children")]
2838        let mut extra_iter = self.extra_children.iter().peekable();
2839        #[cfg(feature = "extra-children")]
2840        let mut emit_idx: usize = 0;
2841        #[cfg(feature = "extra-children")]
2842        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2843            extra_iter
2844                .next()
2845                .unwrap()
2846                .node
2847                .write_to(writer)
2848                .map_err(SerializeError::from)?;
2849        }
2850        {
2851            let val = &self.c_bhvr;
2852            val.write_element("p:cBhvr", writer)?;
2853        }
2854        #[cfg(feature = "extra-children")]
2855        {
2856            emit_idx += 1;
2857        }
2858        #[cfg(feature = "extra-children")]
2859        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2860            extra_iter
2861                .next()
2862                .unwrap()
2863                .node
2864                .write_to(writer)
2865                .map_err(SerializeError::from)?;
2866        }
2867        if let Some(ref val) = self.by {
2868            val.write_element("p:by", writer)?;
2869        }
2870        #[cfg(feature = "extra-children")]
2871        {
2872            emit_idx += 1;
2873        }
2874        #[cfg(feature = "extra-children")]
2875        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2876            extra_iter
2877                .next()
2878                .unwrap()
2879                .node
2880                .write_to(writer)
2881                .map_err(SerializeError::from)?;
2882        }
2883        if let Some(ref val) = self.from {
2884            val.write_element("p:from", writer)?;
2885        }
2886        #[cfg(feature = "extra-children")]
2887        {
2888            emit_idx += 1;
2889        }
2890        #[cfg(feature = "extra-children")]
2891        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2892            extra_iter
2893                .next()
2894                .unwrap()
2895                .node
2896                .write_to(writer)
2897                .map_err(SerializeError::from)?;
2898        }
2899        if let Some(ref val) = self.to {
2900            val.write_element("p:to", writer)?;
2901        }
2902        #[cfg(feature = "extra-children")]
2903        {
2904            emit_idx += 1;
2905        }
2906        #[cfg(feature = "extra-children")]
2907        for extra in extra_iter {
2908            extra.node.write_to(writer).map_err(SerializeError::from)?;
2909        }
2910        Ok(())
2911    }
2912
2913    fn is_empty_element(&self) -> bool {
2914        false
2915    }
2916}
2917
2918impl ToXml for CTTLAnimateEffectBehavior {
2919    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
2920        #[allow(unused_mut)]
2921        let mut start = start;
2922        if let Some(ref val) = self.transition {
2923            {
2924                let s = val.to_string();
2925                start.push_attribute(("transition", s.as_str()));
2926            }
2927        }
2928        if let Some(ref val) = self.filter {
2929            start.push_attribute(("filter", val.as_str()));
2930        }
2931        if let Some(ref val) = self.pr_lst {
2932            start.push_attribute(("prLst", val.as_str()));
2933        }
2934        #[cfg(feature = "extra-attrs")]
2935        for (key, value) in &self.extra_attrs {
2936            start.push_attribute((key.as_str(), value.as_str()));
2937        }
2938        start
2939    }
2940
2941    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
2942        #[cfg(feature = "extra-children")]
2943        let mut extra_iter = self.extra_children.iter().peekable();
2944        #[cfg(feature = "extra-children")]
2945        let mut emit_idx: usize = 0;
2946        #[cfg(feature = "extra-children")]
2947        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2948            extra_iter
2949                .next()
2950                .unwrap()
2951                .node
2952                .write_to(writer)
2953                .map_err(SerializeError::from)?;
2954        }
2955        {
2956            let val = &self.c_bhvr;
2957            val.write_element("p:cBhvr", writer)?;
2958        }
2959        #[cfg(feature = "extra-children")]
2960        {
2961            emit_idx += 1;
2962        }
2963        #[cfg(feature = "extra-children")]
2964        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
2965            extra_iter
2966                .next()
2967                .unwrap()
2968                .node
2969                .write_to(writer)
2970                .map_err(SerializeError::from)?;
2971        }
2972        if let Some(ref val) = self.progress {
2973            val.write_element("p:progress", writer)?;
2974        }
2975        #[cfg(feature = "extra-children")]
2976        {
2977            emit_idx += 1;
2978        }
2979        #[cfg(feature = "extra-children")]
2980        for extra in extra_iter {
2981            extra.node.write_to(writer).map_err(SerializeError::from)?;
2982        }
2983        Ok(())
2984    }
2985
2986    fn is_empty_element(&self) -> bool {
2987        false
2988    }
2989}
2990
2991impl ToXml for CTTLPoint {
2992    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
2993        #[allow(unused_mut)]
2994        let mut start = start;
2995        {
2996            let val = &self.x;
2997            {
2998                let s = val.to_string();
2999                start.push_attribute(("x", s.as_str()));
3000            }
3001        }
3002        {
3003            let val = &self.y;
3004            {
3005                let s = val.to_string();
3006                start.push_attribute(("y", s.as_str()));
3007            }
3008        }
3009        #[cfg(feature = "extra-attrs")]
3010        for (key, value) in &self.extra_attrs {
3011            start.push_attribute((key.as_str(), value.as_str()));
3012        }
3013        start
3014    }
3015
3016    fn is_empty_element(&self) -> bool {
3017        true
3018    }
3019}
3020
3021impl ToXml for CTTLAnimateMotionBehavior {
3022    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
3023        #[allow(unused_mut)]
3024        let mut start = start;
3025        if let Some(ref val) = self.origin {
3026            {
3027                let s = val.to_string();
3028                start.push_attribute(("origin", s.as_str()));
3029            }
3030        }
3031        if let Some(ref val) = self.path {
3032            start.push_attribute(("path", val.as_str()));
3033        }
3034        if let Some(ref val) = self.path_edit_mode {
3035            {
3036                let s = val.to_string();
3037                start.push_attribute(("pathEditMode", s.as_str()));
3038            }
3039        }
3040        if let Some(ref val) = self.r_ang {
3041            {
3042                let s = val.to_string();
3043                start.push_attribute(("rAng", s.as_str()));
3044            }
3045        }
3046        if let Some(ref val) = self.pts_types {
3047            start.push_attribute(("ptsTypes", val.as_str()));
3048        }
3049        #[cfg(feature = "extra-attrs")]
3050        for (key, value) in &self.extra_attrs {
3051            start.push_attribute((key.as_str(), value.as_str()));
3052        }
3053        start
3054    }
3055
3056    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
3057        #[cfg(feature = "extra-children")]
3058        let mut extra_iter = self.extra_children.iter().peekable();
3059        #[cfg(feature = "extra-children")]
3060        let mut emit_idx: usize = 0;
3061        #[cfg(feature = "extra-children")]
3062        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3063            extra_iter
3064                .next()
3065                .unwrap()
3066                .node
3067                .write_to(writer)
3068                .map_err(SerializeError::from)?;
3069        }
3070        {
3071            let val = &self.c_bhvr;
3072            val.write_element("p:cBhvr", writer)?;
3073        }
3074        #[cfg(feature = "extra-children")]
3075        {
3076            emit_idx += 1;
3077        }
3078        #[cfg(feature = "extra-children")]
3079        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3080            extra_iter
3081                .next()
3082                .unwrap()
3083                .node
3084                .write_to(writer)
3085                .map_err(SerializeError::from)?;
3086        }
3087        if let Some(ref val) = self.by {
3088            val.write_element("p:by", writer)?;
3089        }
3090        #[cfg(feature = "extra-children")]
3091        {
3092            emit_idx += 1;
3093        }
3094        #[cfg(feature = "extra-children")]
3095        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3096            extra_iter
3097                .next()
3098                .unwrap()
3099                .node
3100                .write_to(writer)
3101                .map_err(SerializeError::from)?;
3102        }
3103        if let Some(ref val) = self.from {
3104            val.write_element("p:from", writer)?;
3105        }
3106        #[cfg(feature = "extra-children")]
3107        {
3108            emit_idx += 1;
3109        }
3110        #[cfg(feature = "extra-children")]
3111        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3112            extra_iter
3113                .next()
3114                .unwrap()
3115                .node
3116                .write_to(writer)
3117                .map_err(SerializeError::from)?;
3118        }
3119        if let Some(ref val) = self.to {
3120            val.write_element("p:to", writer)?;
3121        }
3122        #[cfg(feature = "extra-children")]
3123        {
3124            emit_idx += 1;
3125        }
3126        #[cfg(feature = "extra-children")]
3127        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3128            extra_iter
3129                .next()
3130                .unwrap()
3131                .node
3132                .write_to(writer)
3133                .map_err(SerializeError::from)?;
3134        }
3135        if let Some(ref val) = self.r_ctr {
3136            val.write_element("p:rCtr", writer)?;
3137        }
3138        #[cfg(feature = "extra-children")]
3139        {
3140            emit_idx += 1;
3141        }
3142        #[cfg(feature = "extra-children")]
3143        for extra in extra_iter {
3144            extra.node.write_to(writer).map_err(SerializeError::from)?;
3145        }
3146        Ok(())
3147    }
3148
3149    fn is_empty_element(&self) -> bool {
3150        false
3151    }
3152}
3153
3154impl ToXml for CTTLAnimateRotationBehavior {
3155    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
3156        #[allow(unused_mut)]
3157        let mut start = start;
3158        if let Some(ref val) = self.by {
3159            {
3160                let s = val.to_string();
3161                start.push_attribute(("by", s.as_str()));
3162            }
3163        }
3164        if let Some(ref val) = self.from {
3165            {
3166                let s = val.to_string();
3167                start.push_attribute(("from", s.as_str()));
3168            }
3169        }
3170        if let Some(ref val) = self.to {
3171            {
3172                let s = val.to_string();
3173                start.push_attribute(("to", s.as_str()));
3174            }
3175        }
3176        #[cfg(feature = "extra-attrs")]
3177        for (key, value) in &self.extra_attrs {
3178            start.push_attribute((key.as_str(), value.as_str()));
3179        }
3180        start
3181    }
3182
3183    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
3184        #[cfg(feature = "extra-children")]
3185        let mut extra_iter = self.extra_children.iter().peekable();
3186        #[cfg(feature = "extra-children")]
3187        let mut emit_idx: usize = 0;
3188        #[cfg(feature = "extra-children")]
3189        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3190            extra_iter
3191                .next()
3192                .unwrap()
3193                .node
3194                .write_to(writer)
3195                .map_err(SerializeError::from)?;
3196        }
3197        {
3198            let val = &self.c_bhvr;
3199            val.write_element("p:cBhvr", writer)?;
3200        }
3201        #[cfg(feature = "extra-children")]
3202        {
3203            emit_idx += 1;
3204        }
3205        #[cfg(feature = "extra-children")]
3206        for extra in extra_iter {
3207            extra.node.write_to(writer).map_err(SerializeError::from)?;
3208        }
3209        Ok(())
3210    }
3211
3212    fn is_empty_element(&self) -> bool {
3213        false
3214    }
3215}
3216
3217impl ToXml for CTTLAnimateScaleBehavior {
3218    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
3219        #[allow(unused_mut)]
3220        let mut start = start;
3221        if let Some(ref val) = self.zoom_contents {
3222            start.push_attribute(("zoomContents", if *val { "1" } else { "0" }));
3223        }
3224        #[cfg(feature = "extra-attrs")]
3225        for (key, value) in &self.extra_attrs {
3226            start.push_attribute((key.as_str(), value.as_str()));
3227        }
3228        start
3229    }
3230
3231    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
3232        #[cfg(feature = "extra-children")]
3233        let mut extra_iter = self.extra_children.iter().peekable();
3234        #[cfg(feature = "extra-children")]
3235        let mut emit_idx: usize = 0;
3236        #[cfg(feature = "extra-children")]
3237        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3238            extra_iter
3239                .next()
3240                .unwrap()
3241                .node
3242                .write_to(writer)
3243                .map_err(SerializeError::from)?;
3244        }
3245        {
3246            let val = &self.c_bhvr;
3247            val.write_element("p:cBhvr", writer)?;
3248        }
3249        #[cfg(feature = "extra-children")]
3250        {
3251            emit_idx += 1;
3252        }
3253        #[cfg(feature = "extra-children")]
3254        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3255            extra_iter
3256                .next()
3257                .unwrap()
3258                .node
3259                .write_to(writer)
3260                .map_err(SerializeError::from)?;
3261        }
3262        if let Some(ref val) = self.by {
3263            val.write_element("p:by", writer)?;
3264        }
3265        #[cfg(feature = "extra-children")]
3266        {
3267            emit_idx += 1;
3268        }
3269        #[cfg(feature = "extra-children")]
3270        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3271            extra_iter
3272                .next()
3273                .unwrap()
3274                .node
3275                .write_to(writer)
3276                .map_err(SerializeError::from)?;
3277        }
3278        if let Some(ref val) = self.from {
3279            val.write_element("p:from", writer)?;
3280        }
3281        #[cfg(feature = "extra-children")]
3282        {
3283            emit_idx += 1;
3284        }
3285        #[cfg(feature = "extra-children")]
3286        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3287            extra_iter
3288                .next()
3289                .unwrap()
3290                .node
3291                .write_to(writer)
3292                .map_err(SerializeError::from)?;
3293        }
3294        if let Some(ref val) = self.to {
3295            val.write_element("p:to", writer)?;
3296        }
3297        #[cfg(feature = "extra-children")]
3298        {
3299            emit_idx += 1;
3300        }
3301        #[cfg(feature = "extra-children")]
3302        for extra in extra_iter {
3303            extra.node.write_to(writer).map_err(SerializeError::from)?;
3304        }
3305        Ok(())
3306    }
3307
3308    fn is_empty_element(&self) -> bool {
3309        false
3310    }
3311}
3312
3313impl ToXml for CTTLCommandBehavior {
3314    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
3315        #[allow(unused_mut)]
3316        let mut start = start;
3317        if let Some(ref val) = self.r#type {
3318            {
3319                let s = val.to_string();
3320                start.push_attribute(("type", s.as_str()));
3321            }
3322        }
3323        if let Some(ref val) = self.cmd {
3324            start.push_attribute(("cmd", val.as_str()));
3325        }
3326        #[cfg(feature = "extra-attrs")]
3327        for (key, value) in &self.extra_attrs {
3328            start.push_attribute((key.as_str(), value.as_str()));
3329        }
3330        start
3331    }
3332
3333    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
3334        #[cfg(feature = "extra-children")]
3335        let mut extra_iter = self.extra_children.iter().peekable();
3336        #[cfg(feature = "extra-children")]
3337        let mut emit_idx: usize = 0;
3338        #[cfg(feature = "extra-children")]
3339        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3340            extra_iter
3341                .next()
3342                .unwrap()
3343                .node
3344                .write_to(writer)
3345                .map_err(SerializeError::from)?;
3346        }
3347        {
3348            let val = &self.c_bhvr;
3349            val.write_element("p:cBhvr", writer)?;
3350        }
3351        #[cfg(feature = "extra-children")]
3352        {
3353            emit_idx += 1;
3354        }
3355        #[cfg(feature = "extra-children")]
3356        for extra in extra_iter {
3357            extra.node.write_to(writer).map_err(SerializeError::from)?;
3358        }
3359        Ok(())
3360    }
3361
3362    fn is_empty_element(&self) -> bool {
3363        false
3364    }
3365}
3366
3367impl ToXml for CTTLSetBehavior {
3368    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
3369        #[cfg(feature = "extra-children")]
3370        let mut extra_iter = self.extra_children.iter().peekable();
3371        #[cfg(feature = "extra-children")]
3372        let mut emit_idx: usize = 0;
3373        #[cfg(feature = "extra-children")]
3374        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3375            extra_iter
3376                .next()
3377                .unwrap()
3378                .node
3379                .write_to(writer)
3380                .map_err(SerializeError::from)?;
3381        }
3382        {
3383            let val = &self.c_bhvr;
3384            val.write_element("p:cBhvr", writer)?;
3385        }
3386        #[cfg(feature = "extra-children")]
3387        {
3388            emit_idx += 1;
3389        }
3390        #[cfg(feature = "extra-children")]
3391        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3392            extra_iter
3393                .next()
3394                .unwrap()
3395                .node
3396                .write_to(writer)
3397                .map_err(SerializeError::from)?;
3398        }
3399        if let Some(ref val) = self.to {
3400            val.write_element("p:to", writer)?;
3401        }
3402        #[cfg(feature = "extra-children")]
3403        {
3404            emit_idx += 1;
3405        }
3406        #[cfg(feature = "extra-children")]
3407        for extra in extra_iter {
3408            extra.node.write_to(writer).map_err(SerializeError::from)?;
3409        }
3410        Ok(())
3411    }
3412
3413    fn is_empty_element(&self) -> bool {
3414        false
3415    }
3416}
3417
3418impl ToXml for CTTLCommonMediaNodeData {
3419    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
3420        #[allow(unused_mut)]
3421        let mut start = start;
3422        if let Some(ref val) = self.vol {
3423            {
3424                let s = val.to_string();
3425                start.push_attribute(("vol", s.as_str()));
3426            }
3427        }
3428        if let Some(ref val) = self.mute {
3429            start.push_attribute(("mute", if *val { "1" } else { "0" }));
3430        }
3431        if let Some(ref val) = self.num_sld {
3432            {
3433                let s = val.to_string();
3434                start.push_attribute(("numSld", s.as_str()));
3435            }
3436        }
3437        if let Some(ref val) = self.show_when_stopped {
3438            start.push_attribute(("showWhenStopped", if *val { "1" } else { "0" }));
3439        }
3440        #[cfg(feature = "extra-attrs")]
3441        for (key, value) in &self.extra_attrs {
3442            start.push_attribute((key.as_str(), value.as_str()));
3443        }
3444        start
3445    }
3446
3447    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
3448        #[cfg(feature = "extra-children")]
3449        let mut extra_iter = self.extra_children.iter().peekable();
3450        #[cfg(feature = "extra-children")]
3451        let mut emit_idx: usize = 0;
3452        #[cfg(feature = "extra-children")]
3453        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3454            extra_iter
3455                .next()
3456                .unwrap()
3457                .node
3458                .write_to(writer)
3459                .map_err(SerializeError::from)?;
3460        }
3461        {
3462            let val = &self.c_tn;
3463            val.write_element("p:cTn", writer)?;
3464        }
3465        #[cfg(feature = "extra-children")]
3466        {
3467            emit_idx += 1;
3468        }
3469        #[cfg(feature = "extra-children")]
3470        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3471            extra_iter
3472                .next()
3473                .unwrap()
3474                .node
3475                .write_to(writer)
3476                .map_err(SerializeError::from)?;
3477        }
3478        {
3479            let val = &self.tgt_el;
3480            val.write_element("p:tgtEl", writer)?;
3481        }
3482        #[cfg(feature = "extra-children")]
3483        {
3484            emit_idx += 1;
3485        }
3486        #[cfg(feature = "extra-children")]
3487        for extra in extra_iter {
3488            extra.node.write_to(writer).map_err(SerializeError::from)?;
3489        }
3490        Ok(())
3491    }
3492
3493    fn is_empty_element(&self) -> bool {
3494        false
3495    }
3496}
3497
3498impl ToXml for CTTLMediaNodeAudio {
3499    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
3500        #[allow(unused_mut)]
3501        let mut start = start;
3502        if let Some(ref val) = self.is_narration {
3503            start.push_attribute(("isNarration", if *val { "1" } else { "0" }));
3504        }
3505        #[cfg(feature = "extra-attrs")]
3506        for (key, value) in &self.extra_attrs {
3507            start.push_attribute((key.as_str(), value.as_str()));
3508        }
3509        start
3510    }
3511
3512    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
3513        #[cfg(feature = "extra-children")]
3514        let mut extra_iter = self.extra_children.iter().peekable();
3515        #[cfg(feature = "extra-children")]
3516        let mut emit_idx: usize = 0;
3517        #[cfg(feature = "extra-children")]
3518        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3519            extra_iter
3520                .next()
3521                .unwrap()
3522                .node
3523                .write_to(writer)
3524                .map_err(SerializeError::from)?;
3525        }
3526        {
3527            let val = &self.c_media_node;
3528            val.write_element("p:cMediaNode", writer)?;
3529        }
3530        #[cfg(feature = "extra-children")]
3531        {
3532            emit_idx += 1;
3533        }
3534        #[cfg(feature = "extra-children")]
3535        for extra in extra_iter {
3536            extra.node.write_to(writer).map_err(SerializeError::from)?;
3537        }
3538        Ok(())
3539    }
3540
3541    fn is_empty_element(&self) -> bool {
3542        false
3543    }
3544}
3545
3546impl ToXml for CTTLMediaNodeVideo {
3547    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
3548        #[allow(unused_mut)]
3549        let mut start = start;
3550        if let Some(ref val) = self.full_scrn {
3551            start.push_attribute(("fullScrn", if *val { "1" } else { "0" }));
3552        }
3553        #[cfg(feature = "extra-attrs")]
3554        for (key, value) in &self.extra_attrs {
3555            start.push_attribute((key.as_str(), value.as_str()));
3556        }
3557        start
3558    }
3559
3560    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
3561        #[cfg(feature = "extra-children")]
3562        let mut extra_iter = self.extra_children.iter().peekable();
3563        #[cfg(feature = "extra-children")]
3564        let mut emit_idx: usize = 0;
3565        #[cfg(feature = "extra-children")]
3566        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3567            extra_iter
3568                .next()
3569                .unwrap()
3570                .node
3571                .write_to(writer)
3572                .map_err(SerializeError::from)?;
3573        }
3574        {
3575            let val = &self.c_media_node;
3576            val.write_element("p:cMediaNode", writer)?;
3577        }
3578        #[cfg(feature = "extra-children")]
3579        {
3580            emit_idx += 1;
3581        }
3582        #[cfg(feature = "extra-children")]
3583        for extra in extra_iter {
3584            extra.node.write_to(writer).map_err(SerializeError::from)?;
3585        }
3586        Ok(())
3587    }
3588
3589    fn is_empty_element(&self) -> bool {
3590        false
3591    }
3592}
3593
3594impl ToXml for PAGTLBuild {
3595    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
3596        #[allow(unused_mut)]
3597        let mut start = start;
3598        {
3599            let val = &self.spid;
3600            {
3601                let s = val.to_string();
3602                start.push_attribute(("spid", s.as_str()));
3603            }
3604        }
3605        {
3606            let val = &self.grp_id;
3607            {
3608                let s = val.to_string();
3609                start.push_attribute(("grpId", s.as_str()));
3610            }
3611        }
3612        if let Some(ref val) = self.ui_expand {
3613            start.push_attribute(("uiExpand", if *val { "1" } else { "0" }));
3614        }
3615        #[cfg(feature = "extra-attrs")]
3616        for (key, value) in &self.extra_attrs {
3617            start.push_attribute((key.as_str(), value.as_str()));
3618        }
3619        start
3620    }
3621
3622    fn is_empty_element(&self) -> bool {
3623        true
3624    }
3625}
3626
3627impl ToXml for CTTLTemplate {
3628    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
3629        #[allow(unused_mut)]
3630        let mut start = start;
3631        if let Some(ref val) = self.lvl {
3632            {
3633                let s = val.to_string();
3634                start.push_attribute(("lvl", s.as_str()));
3635            }
3636        }
3637        #[cfg(feature = "extra-attrs")]
3638        for (key, value) in &self.extra_attrs {
3639            start.push_attribute((key.as_str(), value.as_str()));
3640        }
3641        start
3642    }
3643
3644    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
3645        #[cfg(feature = "extra-children")]
3646        let mut extra_iter = self.extra_children.iter().peekable();
3647        #[cfg(feature = "extra-children")]
3648        let mut emit_idx: usize = 0;
3649        #[cfg(feature = "extra-children")]
3650        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3651            extra_iter
3652                .next()
3653                .unwrap()
3654                .node
3655                .write_to(writer)
3656                .map_err(SerializeError::from)?;
3657        }
3658        {
3659            let val = &self.tn_lst;
3660            val.write_element("p:tnLst", writer)?;
3661        }
3662        #[cfg(feature = "extra-children")]
3663        {
3664            emit_idx += 1;
3665        }
3666        #[cfg(feature = "extra-children")]
3667        for extra in extra_iter {
3668            extra.node.write_to(writer).map_err(SerializeError::from)?;
3669        }
3670        Ok(())
3671    }
3672
3673    fn is_empty_element(&self) -> bool {
3674        false
3675    }
3676}
3677
3678impl ToXml for CTTLTemplateList {
3679    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
3680        #[cfg(feature = "extra-children")]
3681        let mut extra_iter = self.extra_children.iter().peekable();
3682        #[cfg(feature = "extra-children")]
3683        let mut emit_idx: usize = 0;
3684        for item in &self.tmpl {
3685            #[cfg(feature = "extra-children")]
3686            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3687                extra_iter
3688                    .next()
3689                    .unwrap()
3690                    .node
3691                    .write_to(writer)
3692                    .map_err(SerializeError::from)?;
3693            }
3694            item.write_element("p:tmpl", writer)?;
3695            #[cfg(feature = "extra-children")]
3696            {
3697                emit_idx += 1;
3698            }
3699        }
3700        #[cfg(feature = "extra-children")]
3701        for extra in extra_iter {
3702            extra.node.write_to(writer).map_err(SerializeError::from)?;
3703        }
3704        Ok(())
3705    }
3706
3707    fn is_empty_element(&self) -> bool {
3708        if !self.tmpl.is_empty() {
3709            return false;
3710        }
3711        #[cfg(feature = "extra-children")]
3712        if !self.extra_children.is_empty() {
3713            return false;
3714        }
3715        true
3716    }
3717}
3718
3719impl ToXml for CTTLBuildParagraph {
3720    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
3721        #[allow(unused_mut)]
3722        let mut start = start;
3723        {
3724            let val = &self.spid;
3725            {
3726                let s = val.to_string();
3727                start.push_attribute(("spid", s.as_str()));
3728            }
3729        }
3730        {
3731            let val = &self.grp_id;
3732            {
3733                let s = val.to_string();
3734                start.push_attribute(("grpId", s.as_str()));
3735            }
3736        }
3737        if let Some(ref val) = self.ui_expand {
3738            start.push_attribute(("uiExpand", if *val { "1" } else { "0" }));
3739        }
3740        if let Some(ref val) = self.build {
3741            {
3742                let s = val.to_string();
3743                start.push_attribute(("build", s.as_str()));
3744            }
3745        }
3746        if let Some(ref val) = self.bld_lvl {
3747            {
3748                let s = val.to_string();
3749                start.push_attribute(("bldLvl", s.as_str()));
3750            }
3751        }
3752        if let Some(ref val) = self.anim_bg {
3753            start.push_attribute(("animBg", if *val { "1" } else { "0" }));
3754        }
3755        if let Some(ref val) = self.auto_update_anim_bg {
3756            start.push_attribute(("autoUpdateAnimBg", if *val { "1" } else { "0" }));
3757        }
3758        if let Some(ref val) = self.rev {
3759            start.push_attribute(("rev", if *val { "1" } else { "0" }));
3760        }
3761        if let Some(ref val) = self.adv_auto {
3762            {
3763                let s = val.to_string();
3764                start.push_attribute(("advAuto", s.as_str()));
3765            }
3766        }
3767        #[cfg(feature = "extra-attrs")]
3768        for (key, value) in &self.extra_attrs {
3769            start.push_attribute((key.as_str(), value.as_str()));
3770        }
3771        start
3772    }
3773
3774    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
3775        #[cfg(feature = "extra-children")]
3776        let mut extra_iter = self.extra_children.iter().peekable();
3777        #[cfg(feature = "extra-children")]
3778        let mut emit_idx: usize = 0;
3779        #[cfg(feature = "extra-children")]
3780        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3781            extra_iter
3782                .next()
3783                .unwrap()
3784                .node
3785                .write_to(writer)
3786                .map_err(SerializeError::from)?;
3787        }
3788        if let Some(ref val) = self.tmpl_lst {
3789            val.write_element("p:tmplLst", writer)?;
3790        }
3791        #[cfg(feature = "extra-children")]
3792        {
3793            emit_idx += 1;
3794        }
3795        #[cfg(feature = "extra-children")]
3796        for extra in extra_iter {
3797            extra.node.write_to(writer).map_err(SerializeError::from)?;
3798        }
3799        Ok(())
3800    }
3801
3802    fn is_empty_element(&self) -> bool {
3803        if self.tmpl_lst.is_some() {
3804            return false;
3805        }
3806        #[cfg(feature = "extra-children")]
3807        if !self.extra_children.is_empty() {
3808            return false;
3809        }
3810        true
3811    }
3812}
3813
3814impl ToXml for CTTLBuildDiagram {
3815    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
3816        #[allow(unused_mut)]
3817        let mut start = start;
3818        {
3819            let val = &self.spid;
3820            {
3821                let s = val.to_string();
3822                start.push_attribute(("spid", s.as_str()));
3823            }
3824        }
3825        {
3826            let val = &self.grp_id;
3827            {
3828                let s = val.to_string();
3829                start.push_attribute(("grpId", s.as_str()));
3830            }
3831        }
3832        if let Some(ref val) = self.ui_expand {
3833            start.push_attribute(("uiExpand", if *val { "1" } else { "0" }));
3834        }
3835        if let Some(ref val) = self.bld {
3836            {
3837                let s = val.to_string();
3838                start.push_attribute(("bld", s.as_str()));
3839            }
3840        }
3841        #[cfg(feature = "extra-attrs")]
3842        for (key, value) in &self.extra_attrs {
3843            start.push_attribute((key.as_str(), value.as_str()));
3844        }
3845        start
3846    }
3847
3848    fn is_empty_element(&self) -> bool {
3849        true
3850    }
3851}
3852
3853impl ToXml for CTTLOleBuildChart {
3854    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
3855        #[allow(unused_mut)]
3856        let mut start = start;
3857        {
3858            let val = &self.spid;
3859            {
3860                let s = val.to_string();
3861                start.push_attribute(("spid", s.as_str()));
3862            }
3863        }
3864        {
3865            let val = &self.grp_id;
3866            {
3867                let s = val.to_string();
3868                start.push_attribute(("grpId", s.as_str()));
3869            }
3870        }
3871        if let Some(ref val) = self.ui_expand {
3872            start.push_attribute(("uiExpand", if *val { "1" } else { "0" }));
3873        }
3874        if let Some(ref val) = self.bld {
3875            {
3876                let s = val.to_string();
3877                start.push_attribute(("bld", s.as_str()));
3878            }
3879        }
3880        if let Some(ref val) = self.anim_bg {
3881            start.push_attribute(("animBg", if *val { "1" } else { "0" }));
3882        }
3883        #[cfg(feature = "extra-attrs")]
3884        for (key, value) in &self.extra_attrs {
3885            start.push_attribute((key.as_str(), value.as_str()));
3886        }
3887        start
3888    }
3889
3890    fn is_empty_element(&self) -> bool {
3891        true
3892    }
3893}
3894
3895impl ToXml for CTTLGraphicalObjectBuild {
3896    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
3897        #[allow(unused_mut)]
3898        let mut start = start;
3899        {
3900            let val = &self.spid;
3901            {
3902                let s = val.to_string();
3903                start.push_attribute(("spid", s.as_str()));
3904            }
3905        }
3906        {
3907            let val = &self.grp_id;
3908            {
3909                let s = val.to_string();
3910                start.push_attribute(("grpId", s.as_str()));
3911            }
3912        }
3913        if let Some(ref val) = self.ui_expand {
3914            start.push_attribute(("uiExpand", if *val { "1" } else { "0" }));
3915        }
3916        #[cfg(feature = "extra-attrs")]
3917        for (key, value) in &self.extra_attrs {
3918            start.push_attribute((key.as_str(), value.as_str()));
3919        }
3920        start
3921    }
3922
3923    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
3924        #[cfg(feature = "extra-children")]
3925        let mut extra_iter = self.extra_children.iter().peekable();
3926        #[cfg(feature = "extra-children")]
3927        let mut emit_idx: usize = 0;
3928        #[cfg(feature = "extra-children")]
3929        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3930            extra_iter
3931                .next()
3932                .unwrap()
3933                .node
3934                .write_to(writer)
3935                .map_err(SerializeError::from)?;
3936        }
3937        if let Some(ref val) = self.bld_as_one {
3938            val.write_element("p:bldAsOne", writer)?;
3939        }
3940        #[cfg(feature = "extra-children")]
3941        {
3942            emit_idx += 1;
3943        }
3944        #[cfg(feature = "extra-children")]
3945        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3946            extra_iter
3947                .next()
3948                .unwrap()
3949                .node
3950                .write_to(writer)
3951                .map_err(SerializeError::from)?;
3952        }
3953        if let Some(ref val) = self.bld_sub {
3954            val.write_element("p:bldSub", writer)?;
3955        }
3956        #[cfg(feature = "extra-children")]
3957        {
3958            emit_idx += 1;
3959        }
3960        #[cfg(feature = "extra-children")]
3961        for extra in extra_iter {
3962            extra.node.write_to(writer).map_err(SerializeError::from)?;
3963        }
3964        Ok(())
3965    }
3966
3967    fn is_empty_element(&self) -> bool {
3968        if self.bld_as_one.is_some() {
3969            return false;
3970        }
3971        if self.bld_sub.is_some() {
3972            return false;
3973        }
3974        #[cfg(feature = "extra-children")]
3975        if !self.extra_children.is_empty() {
3976            return false;
3977        }
3978        true
3979    }
3980}
3981
3982impl ToXml for CTBuildList {
3983    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
3984        #[cfg(feature = "extra-children")]
3985        let mut extra_iter = self.extra_children.iter().peekable();
3986        #[cfg(feature = "extra-children")]
3987        let mut emit_idx: usize = 0;
3988        for item in &self.bld_p {
3989            #[cfg(feature = "extra-children")]
3990            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
3991                extra_iter
3992                    .next()
3993                    .unwrap()
3994                    .node
3995                    .write_to(writer)
3996                    .map_err(SerializeError::from)?;
3997            }
3998            item.write_element("p:bldP", writer)?;
3999            #[cfg(feature = "extra-children")]
4000            {
4001                emit_idx += 1;
4002            }
4003        }
4004        for item in &self.bld_dgm {
4005            #[cfg(feature = "extra-children")]
4006            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4007                extra_iter
4008                    .next()
4009                    .unwrap()
4010                    .node
4011                    .write_to(writer)
4012                    .map_err(SerializeError::from)?;
4013            }
4014            item.write_element("p:bldDgm", writer)?;
4015            #[cfg(feature = "extra-children")]
4016            {
4017                emit_idx += 1;
4018            }
4019        }
4020        for item in &self.bld_ole_chart {
4021            #[cfg(feature = "extra-children")]
4022            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4023                extra_iter
4024                    .next()
4025                    .unwrap()
4026                    .node
4027                    .write_to(writer)
4028                    .map_err(SerializeError::from)?;
4029            }
4030            item.write_element("p:bldOleChart", writer)?;
4031            #[cfg(feature = "extra-children")]
4032            {
4033                emit_idx += 1;
4034            }
4035        }
4036        for item in &self.bld_graphic {
4037            #[cfg(feature = "extra-children")]
4038            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4039                extra_iter
4040                    .next()
4041                    .unwrap()
4042                    .node
4043                    .write_to(writer)
4044                    .map_err(SerializeError::from)?;
4045            }
4046            item.write_element("p:bldGraphic", writer)?;
4047            #[cfg(feature = "extra-children")]
4048            {
4049                emit_idx += 1;
4050            }
4051        }
4052        #[cfg(feature = "extra-children")]
4053        for extra in extra_iter {
4054            extra.node.write_to(writer).map_err(SerializeError::from)?;
4055        }
4056        Ok(())
4057    }
4058
4059    fn is_empty_element(&self) -> bool {
4060        if !self.bld_p.is_empty() {
4061            return false;
4062        }
4063        if !self.bld_dgm.is_empty() {
4064            return false;
4065        }
4066        if !self.bld_ole_chart.is_empty() {
4067            return false;
4068        }
4069        if !self.bld_graphic.is_empty() {
4070            return false;
4071        }
4072        #[cfg(feature = "extra-children")]
4073        if !self.extra_children.is_empty() {
4074            return false;
4075        }
4076        true
4077    }
4078}
4079
4080impl ToXml for SlideTiming {
4081    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4082        #[cfg(feature = "extra-children")]
4083        let mut extra_iter = self.extra_children.iter().peekable();
4084        #[cfg(feature = "extra-children")]
4085        let mut emit_idx: usize = 0;
4086        #[cfg(feature = "extra-children")]
4087        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4088            extra_iter
4089                .next()
4090                .unwrap()
4091                .node
4092                .write_to(writer)
4093                .map_err(SerializeError::from)?;
4094        }
4095        #[cfg(feature = "pml-animations")]
4096        if let Some(ref val) = self.tn_lst {
4097            val.write_element("p:tnLst", writer)?;
4098        }
4099        #[cfg(feature = "extra-children")]
4100        {
4101            emit_idx += 1;
4102        }
4103        #[cfg(feature = "extra-children")]
4104        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4105            extra_iter
4106                .next()
4107                .unwrap()
4108                .node
4109                .write_to(writer)
4110                .map_err(SerializeError::from)?;
4111        }
4112        #[cfg(feature = "pml-animations")]
4113        if let Some(ref val) = self.bld_lst {
4114            val.write_element("p:bldLst", writer)?;
4115        }
4116        #[cfg(feature = "extra-children")]
4117        {
4118            emit_idx += 1;
4119        }
4120        #[cfg(feature = "extra-children")]
4121        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4122            extra_iter
4123                .next()
4124                .unwrap()
4125                .node
4126                .write_to(writer)
4127                .map_err(SerializeError::from)?;
4128        }
4129        #[cfg(feature = "pml-extensions")]
4130        if let Some(ref val) = self.ext_lst {
4131            val.write_element("p:extLst", writer)?;
4132        }
4133        #[cfg(feature = "extra-children")]
4134        {
4135            emit_idx += 1;
4136        }
4137        #[cfg(feature = "extra-children")]
4138        for extra in extra_iter {
4139            extra.node.write_to(writer).map_err(SerializeError::from)?;
4140        }
4141        Ok(())
4142    }
4143
4144    fn is_empty_element(&self) -> bool {
4145        #[cfg(feature = "pml-animations")]
4146        if self.tn_lst.is_some() {
4147            return false;
4148        }
4149        #[cfg(feature = "pml-animations")]
4150        if self.bld_lst.is_some() {
4151            return false;
4152        }
4153        #[cfg(feature = "pml-extensions")]
4154        if self.ext_lst.is_some() {
4155            return false;
4156        }
4157        #[cfg(feature = "extra-children")]
4158        if !self.extra_children.is_empty() {
4159            return false;
4160        }
4161        true
4162    }
4163}
4164
4165impl ToXml for CTEmpty {
4166    fn is_empty_element(&self) -> bool {
4167        true
4168    }
4169}
4170
4171impl ToXml for CTIndexRange {
4172    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
4173        #[allow(unused_mut)]
4174        let mut start = start;
4175        {
4176            let val = &self.st;
4177            {
4178                let s = val.to_string();
4179                start.push_attribute(("st", s.as_str()));
4180            }
4181        }
4182        {
4183            let val = &self.end;
4184            {
4185                let s = val.to_string();
4186                start.push_attribute(("end", s.as_str()));
4187            }
4188        }
4189        #[cfg(feature = "extra-attrs")]
4190        for (key, value) in &self.extra_attrs {
4191            start.push_attribute((key.as_str(), value.as_str()));
4192        }
4193        start
4194    }
4195
4196    fn is_empty_element(&self) -> bool {
4197        true
4198    }
4199}
4200
4201impl ToXml for CTSlideRelationshipListEntry {
4202    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4203        #[cfg(feature = "extra-children")]
4204        for child in &self.extra_children {
4205            child.node.write_to(writer).map_err(SerializeError::from)?;
4206        }
4207        Ok(())
4208    }
4209
4210    fn is_empty_element(&self) -> bool {
4211        #[cfg(feature = "extra-children")]
4212        if !self.extra_children.is_empty() {
4213            return false;
4214        }
4215        true
4216    }
4217}
4218
4219impl ToXml for CTSlideRelationshipList {
4220    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4221        #[cfg(feature = "extra-children")]
4222        let mut extra_iter = self.extra_children.iter().peekable();
4223        #[cfg(feature = "extra-children")]
4224        let mut emit_idx: usize = 0;
4225        for item in &self.sld {
4226            #[cfg(feature = "extra-children")]
4227            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4228                extra_iter
4229                    .next()
4230                    .unwrap()
4231                    .node
4232                    .write_to(writer)
4233                    .map_err(SerializeError::from)?;
4234            }
4235            item.write_element("p:sld", writer)?;
4236            #[cfg(feature = "extra-children")]
4237            {
4238                emit_idx += 1;
4239            }
4240        }
4241        #[cfg(feature = "extra-children")]
4242        for extra in extra_iter {
4243            extra.node.write_to(writer).map_err(SerializeError::from)?;
4244        }
4245        Ok(())
4246    }
4247
4248    fn is_empty_element(&self) -> bool {
4249        if !self.sld.is_empty() {
4250            return false;
4251        }
4252        #[cfg(feature = "extra-children")]
4253        if !self.extra_children.is_empty() {
4254            return false;
4255        }
4256        true
4257    }
4258}
4259
4260impl ToXml for CTCustomShowId {
4261    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
4262        #[allow(unused_mut)]
4263        let mut start = start;
4264        {
4265            let val = &self.id;
4266            {
4267                let s = val.to_string();
4268                start.push_attribute(("id", s.as_str()));
4269            }
4270        }
4271        #[cfg(feature = "extra-attrs")]
4272        for (key, value) in &self.extra_attrs {
4273            start.push_attribute((key.as_str(), value.as_str()));
4274        }
4275        start
4276    }
4277
4278    fn is_empty_element(&self) -> bool {
4279        true
4280    }
4281}
4282
4283impl ToXml for EGSlideListChoice {
4284    fn write_element<W: Write>(
4285        &self,
4286        _tag: &str,
4287        writer: &mut Writer<W>,
4288    ) -> Result<(), SerializeError> {
4289        match self {
4290            Self::SldAll(inner) => inner.write_element("p:sldAll", writer)?,
4291            Self::SldRg(inner) => inner.write_element("p:sldRg", writer)?,
4292            Self::CustShow(inner) => inner.write_element("p:custShow", writer)?,
4293        }
4294        Ok(())
4295    }
4296}
4297
4298impl ToXml for CTCustomerData {
4299    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4300        #[cfg(feature = "extra-children")]
4301        for child in &self.extra_children {
4302            child.node.write_to(writer).map_err(SerializeError::from)?;
4303        }
4304        Ok(())
4305    }
4306
4307    fn is_empty_element(&self) -> bool {
4308        #[cfg(feature = "extra-children")]
4309        if !self.extra_children.is_empty() {
4310            return false;
4311        }
4312        true
4313    }
4314}
4315
4316impl ToXml for CTTagsData {
4317    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4318        #[cfg(feature = "extra-children")]
4319        for child in &self.extra_children {
4320            child.node.write_to(writer).map_err(SerializeError::from)?;
4321        }
4322        Ok(())
4323    }
4324
4325    fn is_empty_element(&self) -> bool {
4326        #[cfg(feature = "extra-children")]
4327        if !self.extra_children.is_empty() {
4328            return false;
4329        }
4330        true
4331    }
4332}
4333
4334impl ToXml for CTCustomerDataList {
4335    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4336        #[cfg(feature = "extra-children")]
4337        let mut extra_iter = self.extra_children.iter().peekable();
4338        #[cfg(feature = "extra-children")]
4339        let mut emit_idx: usize = 0;
4340        for item in &self.cust_data {
4341            #[cfg(feature = "extra-children")]
4342            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4343                extra_iter
4344                    .next()
4345                    .unwrap()
4346                    .node
4347                    .write_to(writer)
4348                    .map_err(SerializeError::from)?;
4349            }
4350            item.write_element("p:custData", writer)?;
4351            #[cfg(feature = "extra-children")]
4352            {
4353                emit_idx += 1;
4354            }
4355        }
4356        #[cfg(feature = "extra-children")]
4357        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4358            extra_iter
4359                .next()
4360                .unwrap()
4361                .node
4362                .write_to(writer)
4363                .map_err(SerializeError::from)?;
4364        }
4365        if let Some(ref val) = self.tags {
4366            val.write_element("p:tags", writer)?;
4367        }
4368        #[cfg(feature = "extra-children")]
4369        {
4370            emit_idx += 1;
4371        }
4372        #[cfg(feature = "extra-children")]
4373        for extra in extra_iter {
4374            extra.node.write_to(writer).map_err(SerializeError::from)?;
4375        }
4376        Ok(())
4377    }
4378
4379    fn is_empty_element(&self) -> bool {
4380        if !self.cust_data.is_empty() {
4381            return false;
4382        }
4383        if self.tags.is_some() {
4384            return false;
4385        }
4386        #[cfg(feature = "extra-children")]
4387        if !self.extra_children.is_empty() {
4388            return false;
4389        }
4390        true
4391    }
4392}
4393
4394impl ToXml for CTExtension {
4395    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
4396        #[allow(unused_mut)]
4397        let mut start = start;
4398        {
4399            let val = &self.uri;
4400            start.push_attribute(("uri", val.as_str()));
4401        }
4402        #[cfg(feature = "extra-attrs")]
4403        for (key, value) in &self.extra_attrs {
4404            start.push_attribute((key.as_str(), value.as_str()));
4405        }
4406        start
4407    }
4408
4409    fn is_empty_element(&self) -> bool {
4410        true
4411    }
4412}
4413
4414impl ToXml for EGExtensionList {
4415    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4416        #[cfg(feature = "extra-children")]
4417        let mut extra_iter = self.extra_children.iter().peekable();
4418        #[cfg(feature = "extra-children")]
4419        let mut emit_idx: usize = 0;
4420        for item in &self.ext {
4421            #[cfg(feature = "extra-children")]
4422            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4423                extra_iter
4424                    .next()
4425                    .unwrap()
4426                    .node
4427                    .write_to(writer)
4428                    .map_err(SerializeError::from)?;
4429            }
4430            item.write_element("p:ext", writer)?;
4431            #[cfg(feature = "extra-children")]
4432            {
4433                emit_idx += 1;
4434            }
4435        }
4436        #[cfg(feature = "extra-children")]
4437        for extra in extra_iter {
4438            extra.node.write_to(writer).map_err(SerializeError::from)?;
4439        }
4440        Ok(())
4441    }
4442
4443    fn is_empty_element(&self) -> bool {
4444        if !self.ext.is_empty() {
4445            return false;
4446        }
4447        #[cfg(feature = "extra-children")]
4448        if !self.extra_children.is_empty() {
4449            return false;
4450        }
4451        true
4452    }
4453}
4454
4455impl ToXml for CTExtensionList {
4456    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4457        #[cfg(feature = "extra-children")]
4458        let mut extra_iter = self.extra_children.iter().peekable();
4459        #[cfg(feature = "extra-children")]
4460        let mut emit_idx: usize = 0;
4461        for item in &self.ext {
4462            #[cfg(feature = "extra-children")]
4463            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4464                extra_iter
4465                    .next()
4466                    .unwrap()
4467                    .node
4468                    .write_to(writer)
4469                    .map_err(SerializeError::from)?;
4470            }
4471            item.write_element("p:ext", writer)?;
4472            #[cfg(feature = "extra-children")]
4473            {
4474                emit_idx += 1;
4475            }
4476        }
4477        #[cfg(feature = "extra-children")]
4478        for extra in extra_iter {
4479            extra.node.write_to(writer).map_err(SerializeError::from)?;
4480        }
4481        Ok(())
4482    }
4483
4484    fn is_empty_element(&self) -> bool {
4485        if !self.ext.is_empty() {
4486            return false;
4487        }
4488        #[cfg(feature = "extra-children")]
4489        if !self.extra_children.is_empty() {
4490            return false;
4491        }
4492        true
4493    }
4494}
4495
4496impl ToXml for CTExtensionListModify {
4497    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
4498        #[allow(unused_mut)]
4499        let mut start = start;
4500        if let Some(ref val) = self.r#mod {
4501            start.push_attribute(("mod", if *val { "1" } else { "0" }));
4502        }
4503        #[cfg(feature = "extra-attrs")]
4504        for (key, value) in &self.extra_attrs {
4505            start.push_attribute((key.as_str(), value.as_str()));
4506        }
4507        start
4508    }
4509
4510    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4511        #[cfg(feature = "extra-children")]
4512        let mut extra_iter = self.extra_children.iter().peekable();
4513        #[cfg(feature = "extra-children")]
4514        let mut emit_idx: usize = 0;
4515        for item in &self.ext {
4516            #[cfg(feature = "extra-children")]
4517            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4518                extra_iter
4519                    .next()
4520                    .unwrap()
4521                    .node
4522                    .write_to(writer)
4523                    .map_err(SerializeError::from)?;
4524            }
4525            item.write_element("p:ext", writer)?;
4526            #[cfg(feature = "extra-children")]
4527            {
4528                emit_idx += 1;
4529            }
4530        }
4531        #[cfg(feature = "extra-children")]
4532        for extra in extra_iter {
4533            extra.node.write_to(writer).map_err(SerializeError::from)?;
4534        }
4535        Ok(())
4536    }
4537
4538    fn is_empty_element(&self) -> bool {
4539        if !self.ext.is_empty() {
4540            return false;
4541        }
4542        #[cfg(feature = "extra-children")]
4543        if !self.extra_children.is_empty() {
4544            return false;
4545        }
4546        true
4547    }
4548}
4549
4550impl ToXml for CTCommentAuthor {
4551    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
4552        #[allow(unused_mut)]
4553        let mut start = start;
4554        #[cfg(feature = "pml-comments")]
4555        {
4556            let val = &self.id;
4557            {
4558                let s = val.to_string();
4559                start.push_attribute(("id", s.as_str()));
4560            }
4561        }
4562        #[cfg(feature = "pml-comments")]
4563        {
4564            let val = &self.name;
4565            start.push_attribute(("name", val.as_str()));
4566        }
4567        #[cfg(feature = "pml-comments")]
4568        {
4569            let val = &self.initials;
4570            start.push_attribute(("initials", val.as_str()));
4571        }
4572        #[cfg(feature = "pml-comments")]
4573        {
4574            let val = &self.last_idx;
4575            {
4576                let s = val.to_string();
4577                start.push_attribute(("lastIdx", s.as_str()));
4578            }
4579        }
4580        #[cfg(feature = "pml-comments")]
4581        {
4582            let val = &self.clr_idx;
4583            {
4584                let s = val.to_string();
4585                start.push_attribute(("clrIdx", s.as_str()));
4586            }
4587        }
4588        #[cfg(feature = "extra-attrs")]
4589        for (key, value) in &self.extra_attrs {
4590            start.push_attribute((key.as_str(), value.as_str()));
4591        }
4592        start
4593    }
4594
4595    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4596        #[cfg(feature = "extra-children")]
4597        let mut extra_iter = self.extra_children.iter().peekable();
4598        #[cfg(feature = "extra-children")]
4599        let mut emit_idx: usize = 0;
4600        #[cfg(feature = "extra-children")]
4601        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4602            extra_iter
4603                .next()
4604                .unwrap()
4605                .node
4606                .write_to(writer)
4607                .map_err(SerializeError::from)?;
4608        }
4609        #[cfg(feature = "pml-extensions")]
4610        if let Some(ref val) = self.ext_lst {
4611            val.write_element("p:extLst", writer)?;
4612        }
4613        #[cfg(feature = "extra-children")]
4614        {
4615            emit_idx += 1;
4616        }
4617        #[cfg(feature = "extra-children")]
4618        for extra in extra_iter {
4619            extra.node.write_to(writer).map_err(SerializeError::from)?;
4620        }
4621        Ok(())
4622    }
4623
4624    fn is_empty_element(&self) -> bool {
4625        #[cfg(feature = "pml-extensions")]
4626        if self.ext_lst.is_some() {
4627            return false;
4628        }
4629        #[cfg(feature = "extra-children")]
4630        if !self.extra_children.is_empty() {
4631            return false;
4632        }
4633        true
4634    }
4635}
4636
4637impl ToXml for CTCommentAuthorList {
4638    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4639        #[cfg(feature = "extra-children")]
4640        let mut extra_iter = self.extra_children.iter().peekable();
4641        #[cfg(feature = "extra-children")]
4642        let mut emit_idx: usize = 0;
4643        for item in &self.cm_author {
4644            #[cfg(feature = "extra-children")]
4645            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4646                extra_iter
4647                    .next()
4648                    .unwrap()
4649                    .node
4650                    .write_to(writer)
4651                    .map_err(SerializeError::from)?;
4652            }
4653            item.write_element("p:cmAuthor", writer)?;
4654            #[cfg(feature = "extra-children")]
4655            {
4656                emit_idx += 1;
4657            }
4658        }
4659        #[cfg(feature = "extra-children")]
4660        for extra in extra_iter {
4661            extra.node.write_to(writer).map_err(SerializeError::from)?;
4662        }
4663        Ok(())
4664    }
4665
4666    fn is_empty_element(&self) -> bool {
4667        if !self.cm_author.is_empty() {
4668            return false;
4669        }
4670        #[cfg(feature = "extra-children")]
4671        if !self.extra_children.is_empty() {
4672            return false;
4673        }
4674        true
4675    }
4676}
4677
4678impl ToXml for CTComment {
4679    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
4680        #[allow(unused_mut)]
4681        let mut start = start;
4682        #[cfg(feature = "pml-comments")]
4683        {
4684            let val = &self.author_id;
4685            {
4686                let s = val.to_string();
4687                start.push_attribute(("authorId", s.as_str()));
4688            }
4689        }
4690        #[cfg(feature = "pml-comments")]
4691        if let Some(ref val) = self.dt {
4692            start.push_attribute(("dt", val.as_str()));
4693        }
4694        #[cfg(feature = "pml-comments")]
4695        {
4696            let val = &self.idx;
4697            {
4698                let s = val.to_string();
4699                start.push_attribute(("idx", s.as_str()));
4700            }
4701        }
4702        #[cfg(feature = "extra-attrs")]
4703        for (key, value) in &self.extra_attrs {
4704            start.push_attribute((key.as_str(), value.as_str()));
4705        }
4706        start
4707    }
4708
4709    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4710        #[cfg(feature = "extra-children")]
4711        let mut extra_iter = self.extra_children.iter().peekable();
4712        #[cfg(feature = "extra-children")]
4713        let mut emit_idx: usize = 0;
4714        #[cfg(feature = "extra-children")]
4715        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4716            extra_iter
4717                .next()
4718                .unwrap()
4719                .node
4720                .write_to(writer)
4721                .map_err(SerializeError::from)?;
4722        }
4723        #[cfg(feature = "pml-comments")]
4724        {
4725            let val = &self.pos;
4726            val.write_element("p:pos", writer)?;
4727        }
4728        #[cfg(feature = "extra-children")]
4729        {
4730            emit_idx += 1;
4731        }
4732        #[cfg(feature = "extra-children")]
4733        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4734            extra_iter
4735                .next()
4736                .unwrap()
4737                .node
4738                .write_to(writer)
4739                .map_err(SerializeError::from)?;
4740        }
4741        #[cfg(feature = "pml-comments")]
4742        {
4743            let val = &self.text;
4744            {
4745                let start = BytesStart::new("p:text");
4746                writer.write_event(Event::Start(start))?;
4747                writer.write_event(Event::Text(BytesText::new(val.as_str())))?;
4748                writer.write_event(Event::End(BytesEnd::new("p:text")))?;
4749            }
4750        }
4751        #[cfg(feature = "extra-children")]
4752        {
4753            emit_idx += 1;
4754        }
4755        #[cfg(feature = "extra-children")]
4756        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4757            extra_iter
4758                .next()
4759                .unwrap()
4760                .node
4761                .write_to(writer)
4762                .map_err(SerializeError::from)?;
4763        }
4764        #[cfg(feature = "pml-extensions")]
4765        if let Some(ref val) = self.ext_lst {
4766            val.write_element("p:extLst", writer)?;
4767        }
4768        #[cfg(feature = "extra-children")]
4769        {
4770            emit_idx += 1;
4771        }
4772        #[cfg(feature = "extra-children")]
4773        for extra in extra_iter {
4774            extra.node.write_to(writer).map_err(SerializeError::from)?;
4775        }
4776        Ok(())
4777    }
4778
4779    fn is_empty_element(&self) -> bool {
4780        #[cfg(feature = "pml-comments")]
4781        return false;
4782        #[cfg(feature = "pml-comments")]
4783        return false;
4784        #[cfg(feature = "pml-extensions")]
4785        if self.ext_lst.is_some() {
4786            return false;
4787        }
4788        #[cfg(feature = "extra-children")]
4789        if !self.extra_children.is_empty() {
4790            return false;
4791        }
4792        true
4793    }
4794}
4795
4796impl ToXml for CTCommentList {
4797    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4798        #[cfg(feature = "extra-children")]
4799        let mut extra_iter = self.extra_children.iter().peekable();
4800        #[cfg(feature = "extra-children")]
4801        let mut emit_idx: usize = 0;
4802        for item in &self.cm {
4803            #[cfg(feature = "extra-children")]
4804            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4805                extra_iter
4806                    .next()
4807                    .unwrap()
4808                    .node
4809                    .write_to(writer)
4810                    .map_err(SerializeError::from)?;
4811            }
4812            item.write_element("p:cm", writer)?;
4813            #[cfg(feature = "extra-children")]
4814            {
4815                emit_idx += 1;
4816            }
4817        }
4818        #[cfg(feature = "extra-children")]
4819        for extra in extra_iter {
4820            extra.node.write_to(writer).map_err(SerializeError::from)?;
4821        }
4822        Ok(())
4823    }
4824
4825    fn is_empty_element(&self) -> bool {
4826        if !self.cm.is_empty() {
4827            return false;
4828        }
4829        #[cfg(feature = "extra-children")]
4830        if !self.extra_children.is_empty() {
4831            return false;
4832        }
4833        true
4834    }
4835}
4836
4837impl ToXml for PAGOle {
4838    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
4839        #[allow(unused_mut)]
4840        let mut start = start;
4841        if let Some(ref val) = self.name {
4842            start.push_attribute(("name", val.as_str()));
4843        }
4844        if let Some(ref val) = self.show_as_icon {
4845            start.push_attribute(("showAsIcon", if *val { "1" } else { "0" }));
4846        }
4847        if let Some(ref val) = self.img_w {
4848            {
4849                let s = val.to_string();
4850                start.push_attribute(("imgW", s.as_str()));
4851            }
4852        }
4853        if let Some(ref val) = self.img_h {
4854            {
4855                let s = val.to_string();
4856                start.push_attribute(("imgH", s.as_str()));
4857            }
4858        }
4859        #[cfg(feature = "extra-attrs")]
4860        for (key, value) in &self.extra_attrs {
4861            start.push_attribute((key.as_str(), value.as_str()));
4862        }
4863        start
4864    }
4865
4866    fn is_empty_element(&self) -> bool {
4867        true
4868    }
4869}
4870
4871impl ToXml for CTOleObjectEmbed {
4872    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
4873        #[allow(unused_mut)]
4874        let mut start = start;
4875        if let Some(ref val) = self.follow_color_scheme {
4876            {
4877                let s = val.to_string();
4878                start.push_attribute(("followColorScheme", s.as_str()));
4879            }
4880        }
4881        #[cfg(feature = "extra-attrs")]
4882        for (key, value) in &self.extra_attrs {
4883            start.push_attribute((key.as_str(), value.as_str()));
4884        }
4885        start
4886    }
4887
4888    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4889        #[cfg(feature = "extra-children")]
4890        let mut extra_iter = self.extra_children.iter().peekable();
4891        #[cfg(feature = "extra-children")]
4892        let mut emit_idx: usize = 0;
4893        #[cfg(feature = "extra-children")]
4894        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4895            extra_iter
4896                .next()
4897                .unwrap()
4898                .node
4899                .write_to(writer)
4900                .map_err(SerializeError::from)?;
4901        }
4902        if let Some(ref val) = self.ext_lst {
4903            val.write_element("p:extLst", writer)?;
4904        }
4905        #[cfg(feature = "extra-children")]
4906        {
4907            emit_idx += 1;
4908        }
4909        #[cfg(feature = "extra-children")]
4910        for extra in extra_iter {
4911            extra.node.write_to(writer).map_err(SerializeError::from)?;
4912        }
4913        Ok(())
4914    }
4915
4916    fn is_empty_element(&self) -> bool {
4917        if self.ext_lst.is_some() {
4918            return false;
4919        }
4920        #[cfg(feature = "extra-children")]
4921        if !self.extra_children.is_empty() {
4922            return false;
4923        }
4924        true
4925    }
4926}
4927
4928impl ToXml for CTOleObjectLink {
4929    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
4930        #[allow(unused_mut)]
4931        let mut start = start;
4932        if let Some(ref val) = self.update_automatic {
4933            start.push_attribute(("updateAutomatic", if *val { "1" } else { "0" }));
4934        }
4935        #[cfg(feature = "extra-attrs")]
4936        for (key, value) in &self.extra_attrs {
4937            start.push_attribute((key.as_str(), value.as_str()));
4938        }
4939        start
4940    }
4941
4942    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
4943        #[cfg(feature = "extra-children")]
4944        let mut extra_iter = self.extra_children.iter().peekable();
4945        #[cfg(feature = "extra-children")]
4946        let mut emit_idx: usize = 0;
4947        #[cfg(feature = "extra-children")]
4948        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
4949            extra_iter
4950                .next()
4951                .unwrap()
4952                .node
4953                .write_to(writer)
4954                .map_err(SerializeError::from)?;
4955        }
4956        if let Some(ref val) = self.ext_lst {
4957            val.write_element("p:extLst", writer)?;
4958        }
4959        #[cfg(feature = "extra-children")]
4960        {
4961            emit_idx += 1;
4962        }
4963        #[cfg(feature = "extra-children")]
4964        for extra in extra_iter {
4965            extra.node.write_to(writer).map_err(SerializeError::from)?;
4966        }
4967        Ok(())
4968    }
4969
4970    fn is_empty_element(&self) -> bool {
4971        if self.ext_lst.is_some() {
4972            return false;
4973        }
4974        #[cfg(feature = "extra-children")]
4975        if !self.extra_children.is_empty() {
4976            return false;
4977        }
4978        true
4979    }
4980}
4981
4982impl ToXml for CTOleObject {
4983    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
4984        #[allow(unused_mut)]
4985        let mut start = start;
4986        if let Some(ref val) = self.name {
4987            start.push_attribute(("name", val.as_str()));
4988        }
4989        if let Some(ref val) = self.show_as_icon {
4990            start.push_attribute(("showAsIcon", if *val { "1" } else { "0" }));
4991        }
4992        if let Some(ref val) = self.img_w {
4993            {
4994                let s = val.to_string();
4995                start.push_attribute(("imgW", s.as_str()));
4996            }
4997        }
4998        if let Some(ref val) = self.img_h {
4999            {
5000                let s = val.to_string();
5001                start.push_attribute(("imgH", s.as_str()));
5002            }
5003        }
5004        if let Some(ref val) = self.prog_id {
5005            start.push_attribute(("progId", val.as_str()));
5006        }
5007        if let Some(ref val) = self.spid {
5008            {
5009                let s = val.to_string();
5010                start.push_attribute(("spid", s.as_str()));
5011            }
5012        }
5013        #[cfg(feature = "extra-attrs")]
5014        for (key, value) in &self.extra_attrs {
5015            start.push_attribute((key.as_str(), value.as_str()));
5016        }
5017        start
5018    }
5019
5020    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5021        #[cfg(feature = "extra-children")]
5022        let mut extra_iter = self.extra_children.iter().peekable();
5023        #[cfg(feature = "extra-children")]
5024        let mut emit_idx: usize = 0;
5025        #[cfg(feature = "extra-children")]
5026        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5027            extra_iter
5028                .next()
5029                .unwrap()
5030                .node
5031                .write_to(writer)
5032                .map_err(SerializeError::from)?;
5033        }
5034        if let Some(ref val) = self.embed {
5035            val.write_element("p:embed", writer)?;
5036        }
5037        #[cfg(feature = "extra-children")]
5038        {
5039            emit_idx += 1;
5040        }
5041        #[cfg(feature = "extra-children")]
5042        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5043            extra_iter
5044                .next()
5045                .unwrap()
5046                .node
5047                .write_to(writer)
5048                .map_err(SerializeError::from)?;
5049        }
5050        if let Some(ref val) = self.link {
5051            val.write_element("p:link", writer)?;
5052        }
5053        #[cfg(feature = "extra-children")]
5054        {
5055            emit_idx += 1;
5056        }
5057        #[cfg(feature = "extra-children")]
5058        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5059            extra_iter
5060                .next()
5061                .unwrap()
5062                .node
5063                .write_to(writer)
5064                .map_err(SerializeError::from)?;
5065        }
5066        if let Some(ref val) = self.picture {
5067            val.write_element("p:pic", writer)?;
5068        }
5069        #[cfg(feature = "extra-children")]
5070        {
5071            emit_idx += 1;
5072        }
5073        #[cfg(feature = "extra-children")]
5074        for extra in extra_iter {
5075            extra.node.write_to(writer).map_err(SerializeError::from)?;
5076        }
5077        Ok(())
5078    }
5079
5080    fn is_empty_element(&self) -> bool {
5081        if self.embed.is_some() {
5082            return false;
5083        }
5084        if self.link.is_some() {
5085            return false;
5086        }
5087        if self.picture.is_some() {
5088            return false;
5089        }
5090        #[cfg(feature = "extra-children")]
5091        if !self.extra_children.is_empty() {
5092            return false;
5093        }
5094        true
5095    }
5096}
5097
5098impl ToXml for CTControl {
5099    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
5100        #[allow(unused_mut)]
5101        let mut start = start;
5102        if let Some(ref val) = self.name {
5103            start.push_attribute(("name", val.as_str()));
5104        }
5105        if let Some(ref val) = self.show_as_icon {
5106            start.push_attribute(("showAsIcon", if *val { "1" } else { "0" }));
5107        }
5108        if let Some(ref val) = self.img_w {
5109            {
5110                let s = val.to_string();
5111                start.push_attribute(("imgW", s.as_str()));
5112            }
5113        }
5114        if let Some(ref val) = self.img_h {
5115            {
5116                let s = val.to_string();
5117                start.push_attribute(("imgH", s.as_str()));
5118            }
5119        }
5120        if let Some(ref val) = self.spid {
5121            {
5122                let s = val.to_string();
5123                start.push_attribute(("spid", s.as_str()));
5124            }
5125        }
5126        #[cfg(feature = "extra-attrs")]
5127        for (key, value) in &self.extra_attrs {
5128            start.push_attribute((key.as_str(), value.as_str()));
5129        }
5130        start
5131    }
5132
5133    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5134        #[cfg(feature = "extra-children")]
5135        let mut extra_iter = self.extra_children.iter().peekable();
5136        #[cfg(feature = "extra-children")]
5137        let mut emit_idx: usize = 0;
5138        #[cfg(feature = "extra-children")]
5139        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5140            extra_iter
5141                .next()
5142                .unwrap()
5143                .node
5144                .write_to(writer)
5145                .map_err(SerializeError::from)?;
5146        }
5147        if let Some(ref val) = self.ext_lst {
5148            val.write_element("p:extLst", writer)?;
5149        }
5150        #[cfg(feature = "extra-children")]
5151        {
5152            emit_idx += 1;
5153        }
5154        #[cfg(feature = "extra-children")]
5155        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5156            extra_iter
5157                .next()
5158                .unwrap()
5159                .node
5160                .write_to(writer)
5161                .map_err(SerializeError::from)?;
5162        }
5163        if let Some(ref val) = self.picture {
5164            val.write_element("p:pic", writer)?;
5165        }
5166        #[cfg(feature = "extra-children")]
5167        {
5168            emit_idx += 1;
5169        }
5170        #[cfg(feature = "extra-children")]
5171        for extra in extra_iter {
5172            extra.node.write_to(writer).map_err(SerializeError::from)?;
5173        }
5174        Ok(())
5175    }
5176
5177    fn is_empty_element(&self) -> bool {
5178        if self.ext_lst.is_some() {
5179            return false;
5180        }
5181        if self.picture.is_some() {
5182            return false;
5183        }
5184        #[cfg(feature = "extra-children")]
5185        if !self.extra_children.is_empty() {
5186            return false;
5187        }
5188        true
5189    }
5190}
5191
5192impl ToXml for CTControlList {
5193    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5194        #[cfg(feature = "extra-children")]
5195        let mut extra_iter = self.extra_children.iter().peekable();
5196        #[cfg(feature = "extra-children")]
5197        let mut emit_idx: usize = 0;
5198        for item in &self.control {
5199            #[cfg(feature = "extra-children")]
5200            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5201                extra_iter
5202                    .next()
5203                    .unwrap()
5204                    .node
5205                    .write_to(writer)
5206                    .map_err(SerializeError::from)?;
5207            }
5208            item.write_element("p:control", writer)?;
5209            #[cfg(feature = "extra-children")]
5210            {
5211                emit_idx += 1;
5212            }
5213        }
5214        #[cfg(feature = "extra-children")]
5215        for extra in extra_iter {
5216            extra.node.write_to(writer).map_err(SerializeError::from)?;
5217        }
5218        Ok(())
5219    }
5220
5221    fn is_empty_element(&self) -> bool {
5222        if !self.control.is_empty() {
5223            return false;
5224        }
5225        #[cfg(feature = "extra-children")]
5226        if !self.extra_children.is_empty() {
5227            return false;
5228        }
5229        true
5230    }
5231}
5232
5233impl ToXml for CTSlideIdListEntry {
5234    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
5235        #[allow(unused_mut)]
5236        let mut start = start;
5237        {
5238            let val = &self.id;
5239            {
5240                let s = val.to_string();
5241                start.push_attribute(("id", s.as_str()));
5242            }
5243        }
5244        #[cfg(feature = "extra-attrs")]
5245        for (key, value) in &self.extra_attrs {
5246            start.push_attribute((key.as_str(), value.as_str()));
5247        }
5248        start
5249    }
5250
5251    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5252        #[cfg(feature = "extra-children")]
5253        let mut extra_iter = self.extra_children.iter().peekable();
5254        #[cfg(feature = "extra-children")]
5255        let mut emit_idx: usize = 0;
5256        #[cfg(feature = "extra-children")]
5257        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5258            extra_iter
5259                .next()
5260                .unwrap()
5261                .node
5262                .write_to(writer)
5263                .map_err(SerializeError::from)?;
5264        }
5265        if let Some(ref val) = self.ext_lst {
5266            val.write_element("p:extLst", writer)?;
5267        }
5268        #[cfg(feature = "extra-children")]
5269        {
5270            emit_idx += 1;
5271        }
5272        #[cfg(feature = "extra-children")]
5273        for extra in extra_iter {
5274            extra.node.write_to(writer).map_err(SerializeError::from)?;
5275        }
5276        Ok(())
5277    }
5278
5279    fn is_empty_element(&self) -> bool {
5280        if self.ext_lst.is_some() {
5281            return false;
5282        }
5283        #[cfg(feature = "extra-children")]
5284        if !self.extra_children.is_empty() {
5285            return false;
5286        }
5287        true
5288    }
5289}
5290
5291impl ToXml for SlideIdList {
5292    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5293        #[cfg(feature = "extra-children")]
5294        let mut extra_iter = self.extra_children.iter().peekable();
5295        #[cfg(feature = "extra-children")]
5296        let mut emit_idx: usize = 0;
5297        for item in &self.sld_id {
5298            #[cfg(feature = "extra-children")]
5299            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5300                extra_iter
5301                    .next()
5302                    .unwrap()
5303                    .node
5304                    .write_to(writer)
5305                    .map_err(SerializeError::from)?;
5306            }
5307            item.write_element("p:sldId", writer)?;
5308            #[cfg(feature = "extra-children")]
5309            {
5310                emit_idx += 1;
5311            }
5312        }
5313        #[cfg(feature = "extra-children")]
5314        for extra in extra_iter {
5315            extra.node.write_to(writer).map_err(SerializeError::from)?;
5316        }
5317        Ok(())
5318    }
5319
5320    fn is_empty_element(&self) -> bool {
5321        if !self.sld_id.is_empty() {
5322            return false;
5323        }
5324        #[cfg(feature = "extra-children")]
5325        if !self.extra_children.is_empty() {
5326            return false;
5327        }
5328        true
5329    }
5330}
5331
5332impl ToXml for CTSlideMasterIdListEntry {
5333    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
5334        #[allow(unused_mut)]
5335        let mut start = start;
5336        if let Some(ref val) = self.id {
5337            {
5338                let s = val.to_string();
5339                start.push_attribute(("id", s.as_str()));
5340            }
5341        }
5342        #[cfg(feature = "extra-attrs")]
5343        for (key, value) in &self.extra_attrs {
5344            start.push_attribute((key.as_str(), value.as_str()));
5345        }
5346        start
5347    }
5348
5349    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5350        #[cfg(feature = "extra-children")]
5351        let mut extra_iter = self.extra_children.iter().peekable();
5352        #[cfg(feature = "extra-children")]
5353        let mut emit_idx: usize = 0;
5354        #[cfg(feature = "extra-children")]
5355        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5356            extra_iter
5357                .next()
5358                .unwrap()
5359                .node
5360                .write_to(writer)
5361                .map_err(SerializeError::from)?;
5362        }
5363        if let Some(ref val) = self.ext_lst {
5364            val.write_element("p:extLst", writer)?;
5365        }
5366        #[cfg(feature = "extra-children")]
5367        {
5368            emit_idx += 1;
5369        }
5370        #[cfg(feature = "extra-children")]
5371        for extra in extra_iter {
5372            extra.node.write_to(writer).map_err(SerializeError::from)?;
5373        }
5374        Ok(())
5375    }
5376
5377    fn is_empty_element(&self) -> bool {
5378        if self.ext_lst.is_some() {
5379            return false;
5380        }
5381        #[cfg(feature = "extra-children")]
5382        if !self.extra_children.is_empty() {
5383            return false;
5384        }
5385        true
5386    }
5387}
5388
5389impl ToXml for CTSlideMasterIdList {
5390    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5391        #[cfg(feature = "extra-children")]
5392        let mut extra_iter = self.extra_children.iter().peekable();
5393        #[cfg(feature = "extra-children")]
5394        let mut emit_idx: usize = 0;
5395        for item in &self.sld_master_id {
5396            #[cfg(feature = "extra-children")]
5397            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5398                extra_iter
5399                    .next()
5400                    .unwrap()
5401                    .node
5402                    .write_to(writer)
5403                    .map_err(SerializeError::from)?;
5404            }
5405            item.write_element("p:sldMasterId", writer)?;
5406            #[cfg(feature = "extra-children")]
5407            {
5408                emit_idx += 1;
5409            }
5410        }
5411        #[cfg(feature = "extra-children")]
5412        for extra in extra_iter {
5413            extra.node.write_to(writer).map_err(SerializeError::from)?;
5414        }
5415        Ok(())
5416    }
5417
5418    fn is_empty_element(&self) -> bool {
5419        if !self.sld_master_id.is_empty() {
5420            return false;
5421        }
5422        #[cfg(feature = "extra-children")]
5423        if !self.extra_children.is_empty() {
5424            return false;
5425        }
5426        true
5427    }
5428}
5429
5430impl ToXml for CTNotesMasterIdListEntry {
5431    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5432        #[cfg(feature = "extra-children")]
5433        let mut extra_iter = self.extra_children.iter().peekable();
5434        #[cfg(feature = "extra-children")]
5435        let mut emit_idx: usize = 0;
5436        #[cfg(feature = "extra-children")]
5437        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5438            extra_iter
5439                .next()
5440                .unwrap()
5441                .node
5442                .write_to(writer)
5443                .map_err(SerializeError::from)?;
5444        }
5445        if let Some(ref val) = self.ext_lst {
5446            val.write_element("p:extLst", writer)?;
5447        }
5448        #[cfg(feature = "extra-children")]
5449        {
5450            emit_idx += 1;
5451        }
5452        #[cfg(feature = "extra-children")]
5453        for extra in extra_iter {
5454            extra.node.write_to(writer).map_err(SerializeError::from)?;
5455        }
5456        Ok(())
5457    }
5458
5459    fn is_empty_element(&self) -> bool {
5460        if self.ext_lst.is_some() {
5461            return false;
5462        }
5463        #[cfg(feature = "extra-children")]
5464        if !self.extra_children.is_empty() {
5465            return false;
5466        }
5467        true
5468    }
5469}
5470
5471impl ToXml for CTNotesMasterIdList {
5472    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5473        #[cfg(feature = "extra-children")]
5474        let mut extra_iter = self.extra_children.iter().peekable();
5475        #[cfg(feature = "extra-children")]
5476        let mut emit_idx: usize = 0;
5477        #[cfg(feature = "extra-children")]
5478        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5479            extra_iter
5480                .next()
5481                .unwrap()
5482                .node
5483                .write_to(writer)
5484                .map_err(SerializeError::from)?;
5485        }
5486        if let Some(ref val) = self.notes_master_id {
5487            val.write_element("p:notesMasterId", writer)?;
5488        }
5489        #[cfg(feature = "extra-children")]
5490        {
5491            emit_idx += 1;
5492        }
5493        #[cfg(feature = "extra-children")]
5494        for extra in extra_iter {
5495            extra.node.write_to(writer).map_err(SerializeError::from)?;
5496        }
5497        Ok(())
5498    }
5499
5500    fn is_empty_element(&self) -> bool {
5501        if self.notes_master_id.is_some() {
5502            return false;
5503        }
5504        #[cfg(feature = "extra-children")]
5505        if !self.extra_children.is_empty() {
5506            return false;
5507        }
5508        true
5509    }
5510}
5511
5512impl ToXml for CTHandoutMasterIdListEntry {
5513    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5514        #[cfg(feature = "extra-children")]
5515        let mut extra_iter = self.extra_children.iter().peekable();
5516        #[cfg(feature = "extra-children")]
5517        let mut emit_idx: usize = 0;
5518        #[cfg(feature = "extra-children")]
5519        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5520            extra_iter
5521                .next()
5522                .unwrap()
5523                .node
5524                .write_to(writer)
5525                .map_err(SerializeError::from)?;
5526        }
5527        if let Some(ref val) = self.ext_lst {
5528            val.write_element("p:extLst", writer)?;
5529        }
5530        #[cfg(feature = "extra-children")]
5531        {
5532            emit_idx += 1;
5533        }
5534        #[cfg(feature = "extra-children")]
5535        for extra in extra_iter {
5536            extra.node.write_to(writer).map_err(SerializeError::from)?;
5537        }
5538        Ok(())
5539    }
5540
5541    fn is_empty_element(&self) -> bool {
5542        if self.ext_lst.is_some() {
5543            return false;
5544        }
5545        #[cfg(feature = "extra-children")]
5546        if !self.extra_children.is_empty() {
5547            return false;
5548        }
5549        true
5550    }
5551}
5552
5553impl ToXml for CTHandoutMasterIdList {
5554    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5555        #[cfg(feature = "extra-children")]
5556        let mut extra_iter = self.extra_children.iter().peekable();
5557        #[cfg(feature = "extra-children")]
5558        let mut emit_idx: usize = 0;
5559        #[cfg(feature = "extra-children")]
5560        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5561            extra_iter
5562                .next()
5563                .unwrap()
5564                .node
5565                .write_to(writer)
5566                .map_err(SerializeError::from)?;
5567        }
5568        if let Some(ref val) = self.handout_master_id {
5569            val.write_element("p:handoutMasterId", writer)?;
5570        }
5571        #[cfg(feature = "extra-children")]
5572        {
5573            emit_idx += 1;
5574        }
5575        #[cfg(feature = "extra-children")]
5576        for extra in extra_iter {
5577            extra.node.write_to(writer).map_err(SerializeError::from)?;
5578        }
5579        Ok(())
5580    }
5581
5582    fn is_empty_element(&self) -> bool {
5583        if self.handout_master_id.is_some() {
5584            return false;
5585        }
5586        #[cfg(feature = "extra-children")]
5587        if !self.extra_children.is_empty() {
5588            return false;
5589        }
5590        true
5591    }
5592}
5593
5594impl ToXml for CTEmbeddedFontDataId {
5595    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5596        #[cfg(feature = "extra-children")]
5597        for child in &self.extra_children {
5598            child.node.write_to(writer).map_err(SerializeError::from)?;
5599        }
5600        Ok(())
5601    }
5602
5603    fn is_empty_element(&self) -> bool {
5604        #[cfg(feature = "extra-children")]
5605        if !self.extra_children.is_empty() {
5606            return false;
5607        }
5608        true
5609    }
5610}
5611
5612impl ToXml for CTEmbeddedFontListEntry {
5613    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5614        #[cfg(feature = "extra-children")]
5615        let mut extra_iter = self.extra_children.iter().peekable();
5616        #[cfg(feature = "extra-children")]
5617        let mut emit_idx: usize = 0;
5618        #[cfg(feature = "extra-children")]
5619        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5620            extra_iter
5621                .next()
5622                .unwrap()
5623                .node
5624                .write_to(writer)
5625                .map_err(SerializeError::from)?;
5626        }
5627        {
5628            let val = &self.font;
5629            val.write_element("p:font", writer)?;
5630        }
5631        #[cfg(feature = "extra-children")]
5632        {
5633            emit_idx += 1;
5634        }
5635        #[cfg(feature = "extra-children")]
5636        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5637            extra_iter
5638                .next()
5639                .unwrap()
5640                .node
5641                .write_to(writer)
5642                .map_err(SerializeError::from)?;
5643        }
5644        if let Some(ref val) = self.regular {
5645            val.write_element("p:regular", writer)?;
5646        }
5647        #[cfg(feature = "extra-children")]
5648        {
5649            emit_idx += 1;
5650        }
5651        #[cfg(feature = "extra-children")]
5652        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5653            extra_iter
5654                .next()
5655                .unwrap()
5656                .node
5657                .write_to(writer)
5658                .map_err(SerializeError::from)?;
5659        }
5660        if let Some(ref val) = self.bold {
5661            val.write_element("p:bold", writer)?;
5662        }
5663        #[cfg(feature = "extra-children")]
5664        {
5665            emit_idx += 1;
5666        }
5667        #[cfg(feature = "extra-children")]
5668        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5669            extra_iter
5670                .next()
5671                .unwrap()
5672                .node
5673                .write_to(writer)
5674                .map_err(SerializeError::from)?;
5675        }
5676        if let Some(ref val) = self.italic {
5677            val.write_element("p:italic", writer)?;
5678        }
5679        #[cfg(feature = "extra-children")]
5680        {
5681            emit_idx += 1;
5682        }
5683        #[cfg(feature = "extra-children")]
5684        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5685            extra_iter
5686                .next()
5687                .unwrap()
5688                .node
5689                .write_to(writer)
5690                .map_err(SerializeError::from)?;
5691        }
5692        if let Some(ref val) = self.bold_italic {
5693            val.write_element("p:boldItalic", writer)?;
5694        }
5695        #[cfg(feature = "extra-children")]
5696        {
5697            emit_idx += 1;
5698        }
5699        #[cfg(feature = "extra-children")]
5700        for extra in extra_iter {
5701            extra.node.write_to(writer).map_err(SerializeError::from)?;
5702        }
5703        Ok(())
5704    }
5705
5706    fn is_empty_element(&self) -> bool {
5707        false
5708    }
5709}
5710
5711impl ToXml for CTEmbeddedFontList {
5712    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5713        #[cfg(feature = "extra-children")]
5714        let mut extra_iter = self.extra_children.iter().peekable();
5715        #[cfg(feature = "extra-children")]
5716        let mut emit_idx: usize = 0;
5717        for item in &self.embedded_font {
5718            #[cfg(feature = "extra-children")]
5719            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5720                extra_iter
5721                    .next()
5722                    .unwrap()
5723                    .node
5724                    .write_to(writer)
5725                    .map_err(SerializeError::from)?;
5726            }
5727            item.write_element("p:embeddedFont", writer)?;
5728            #[cfg(feature = "extra-children")]
5729            {
5730                emit_idx += 1;
5731            }
5732        }
5733        #[cfg(feature = "extra-children")]
5734        for extra in extra_iter {
5735            extra.node.write_to(writer).map_err(SerializeError::from)?;
5736        }
5737        Ok(())
5738    }
5739
5740    fn is_empty_element(&self) -> bool {
5741        if !self.embedded_font.is_empty() {
5742            return false;
5743        }
5744        #[cfg(feature = "extra-children")]
5745        if !self.extra_children.is_empty() {
5746            return false;
5747        }
5748        true
5749    }
5750}
5751
5752impl ToXml for CTSmartTags {
5753    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5754        #[cfg(feature = "extra-children")]
5755        for child in &self.extra_children {
5756            child.node.write_to(writer).map_err(SerializeError::from)?;
5757        }
5758        Ok(())
5759    }
5760
5761    fn is_empty_element(&self) -> bool {
5762        #[cfg(feature = "extra-children")]
5763        if !self.extra_children.is_empty() {
5764            return false;
5765        }
5766        true
5767    }
5768}
5769
5770impl ToXml for CTCustomShow {
5771    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
5772        #[allow(unused_mut)]
5773        let mut start = start;
5774        {
5775            let val = &self.name;
5776            start.push_attribute(("name", val.as_str()));
5777        }
5778        {
5779            let val = &self.id;
5780            {
5781                let s = val.to_string();
5782                start.push_attribute(("id", s.as_str()));
5783            }
5784        }
5785        #[cfg(feature = "extra-attrs")]
5786        for (key, value) in &self.extra_attrs {
5787            start.push_attribute((key.as_str(), value.as_str()));
5788        }
5789        start
5790    }
5791
5792    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5793        #[cfg(feature = "extra-children")]
5794        let mut extra_iter = self.extra_children.iter().peekable();
5795        #[cfg(feature = "extra-children")]
5796        let mut emit_idx: usize = 0;
5797        #[cfg(feature = "extra-children")]
5798        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5799            extra_iter
5800                .next()
5801                .unwrap()
5802                .node
5803                .write_to(writer)
5804                .map_err(SerializeError::from)?;
5805        }
5806        {
5807            let val = &self.sld_lst;
5808            val.write_element("p:sldLst", writer)?;
5809        }
5810        #[cfg(feature = "extra-children")]
5811        {
5812            emit_idx += 1;
5813        }
5814        #[cfg(feature = "extra-children")]
5815        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5816            extra_iter
5817                .next()
5818                .unwrap()
5819                .node
5820                .write_to(writer)
5821                .map_err(SerializeError::from)?;
5822        }
5823        if let Some(ref val) = self.ext_lst {
5824            val.write_element("p:extLst", writer)?;
5825        }
5826        #[cfg(feature = "extra-children")]
5827        {
5828            emit_idx += 1;
5829        }
5830        #[cfg(feature = "extra-children")]
5831        for extra in extra_iter {
5832            extra.node.write_to(writer).map_err(SerializeError::from)?;
5833        }
5834        Ok(())
5835    }
5836
5837    fn is_empty_element(&self) -> bool {
5838        false
5839    }
5840}
5841
5842impl ToXml for CTCustomShowList {
5843    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5844        #[cfg(feature = "extra-children")]
5845        let mut extra_iter = self.extra_children.iter().peekable();
5846        #[cfg(feature = "extra-children")]
5847        let mut emit_idx: usize = 0;
5848        for item in &self.cust_show {
5849            #[cfg(feature = "extra-children")]
5850            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5851                extra_iter
5852                    .next()
5853                    .unwrap()
5854                    .node
5855                    .write_to(writer)
5856                    .map_err(SerializeError::from)?;
5857            }
5858            item.write_element("p:custShow", writer)?;
5859            #[cfg(feature = "extra-children")]
5860            {
5861                emit_idx += 1;
5862            }
5863        }
5864        #[cfg(feature = "extra-children")]
5865        for extra in extra_iter {
5866            extra.node.write_to(writer).map_err(SerializeError::from)?;
5867        }
5868        Ok(())
5869    }
5870
5871    fn is_empty_element(&self) -> bool {
5872        if !self.cust_show.is_empty() {
5873            return false;
5874        }
5875        #[cfg(feature = "extra-children")]
5876        if !self.extra_children.is_empty() {
5877            return false;
5878        }
5879        true
5880    }
5881}
5882
5883impl ToXml for CTPhotoAlbum {
5884    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
5885        #[allow(unused_mut)]
5886        let mut start = start;
5887        if let Some(ref val) = self.bw {
5888            start.push_attribute(("bw", if *val { "1" } else { "0" }));
5889        }
5890        if let Some(ref val) = self.show_captions {
5891            start.push_attribute(("showCaptions", if *val { "1" } else { "0" }));
5892        }
5893        if let Some(ref val) = self.layout {
5894            {
5895                let s = val.to_string();
5896                start.push_attribute(("layout", s.as_str()));
5897            }
5898        }
5899        if let Some(ref val) = self.frame {
5900            {
5901                let s = val.to_string();
5902                start.push_attribute(("frame", s.as_str()));
5903            }
5904        }
5905        #[cfg(feature = "extra-attrs")]
5906        for (key, value) in &self.extra_attrs {
5907            start.push_attribute((key.as_str(), value.as_str()));
5908        }
5909        start
5910    }
5911
5912    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
5913        #[cfg(feature = "extra-children")]
5914        let mut extra_iter = self.extra_children.iter().peekable();
5915        #[cfg(feature = "extra-children")]
5916        let mut emit_idx: usize = 0;
5917        #[cfg(feature = "extra-children")]
5918        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
5919            extra_iter
5920                .next()
5921                .unwrap()
5922                .node
5923                .write_to(writer)
5924                .map_err(SerializeError::from)?;
5925        }
5926        if let Some(ref val) = self.ext_lst {
5927            val.write_element("p:extLst", writer)?;
5928        }
5929        #[cfg(feature = "extra-children")]
5930        {
5931            emit_idx += 1;
5932        }
5933        #[cfg(feature = "extra-children")]
5934        for extra in extra_iter {
5935            extra.node.write_to(writer).map_err(SerializeError::from)?;
5936        }
5937        Ok(())
5938    }
5939
5940    fn is_empty_element(&self) -> bool {
5941        if self.ext_lst.is_some() {
5942            return false;
5943        }
5944        #[cfg(feature = "extra-children")]
5945        if !self.extra_children.is_empty() {
5946            return false;
5947        }
5948        true
5949    }
5950}
5951
5952impl ToXml for CTSlideSize {
5953    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
5954        #[allow(unused_mut)]
5955        let mut start = start;
5956        {
5957            let val = &self.cx;
5958            {
5959                let s = val.to_string();
5960                start.push_attribute(("cx", s.as_str()));
5961            }
5962        }
5963        {
5964            let val = &self.cy;
5965            {
5966                let s = val.to_string();
5967                start.push_attribute(("cy", s.as_str()));
5968            }
5969        }
5970        if let Some(ref val) = self.r#type {
5971            {
5972                let s = val.to_string();
5973                start.push_attribute(("type", s.as_str()));
5974            }
5975        }
5976        #[cfg(feature = "extra-attrs")]
5977        for (key, value) in &self.extra_attrs {
5978            start.push_attribute((key.as_str(), value.as_str()));
5979        }
5980        start
5981    }
5982
5983    fn is_empty_element(&self) -> bool {
5984        true
5985    }
5986}
5987
5988impl ToXml for CTKinsoku {
5989    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
5990        #[allow(unused_mut)]
5991        let mut start = start;
5992        if let Some(ref val) = self.lang {
5993            start.push_attribute(("lang", val.as_str()));
5994        }
5995        {
5996            let val = &self.inval_st_chars;
5997            start.push_attribute(("invalStChars", val.as_str()));
5998        }
5999        {
6000            let val = &self.inval_end_chars;
6001            start.push_attribute(("invalEndChars", val.as_str()));
6002        }
6003        #[cfg(feature = "extra-attrs")]
6004        for (key, value) in &self.extra_attrs {
6005            start.push_attribute((key.as_str(), value.as_str()));
6006        }
6007        start
6008    }
6009
6010    fn is_empty_element(&self) -> bool {
6011        true
6012    }
6013}
6014
6015impl ToXml for CTModifyVerifier {
6016    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
6017        #[allow(unused_mut)]
6018        let mut start = start;
6019        if let Some(ref val) = self.algorithm_name {
6020            start.push_attribute(("algorithmName", val.as_str()));
6021        }
6022        if let Some(ref val) = self.hash_value {
6023            {
6024                let b64 = encode_base64(val);
6025                start.push_attribute(("hashValue", b64.as_str()));
6026            }
6027        }
6028        if let Some(ref val) = self.salt_value {
6029            {
6030                let b64 = encode_base64(val);
6031                start.push_attribute(("saltValue", b64.as_str()));
6032            }
6033        }
6034        if let Some(ref val) = self.spin_value {
6035            {
6036                let s = val.to_string();
6037                start.push_attribute(("spinValue", s.as_str()));
6038            }
6039        }
6040        if let Some(ref val) = self.crypt_provider_type {
6041            {
6042                let s = val.to_string();
6043                start.push_attribute(("cryptProviderType", s.as_str()));
6044            }
6045        }
6046        if let Some(ref val) = self.crypt_algorithm_class {
6047            {
6048                let s = val.to_string();
6049                start.push_attribute(("cryptAlgorithmClass", s.as_str()));
6050            }
6051        }
6052        if let Some(ref val) = self.crypt_algorithm_type {
6053            {
6054                let s = val.to_string();
6055                start.push_attribute(("cryptAlgorithmType", s.as_str()));
6056            }
6057        }
6058        if let Some(ref val) = self.crypt_algorithm_sid {
6059            {
6060                let s = val.to_string();
6061                start.push_attribute(("cryptAlgorithmSid", s.as_str()));
6062            }
6063        }
6064        if let Some(ref val) = self.spin_count {
6065            {
6066                let s = val.to_string();
6067                start.push_attribute(("spinCount", s.as_str()));
6068            }
6069        }
6070        if let Some(ref val) = self.salt_data {
6071            {
6072                let b64 = encode_base64(val);
6073                start.push_attribute(("saltData", b64.as_str()));
6074            }
6075        }
6076        if let Some(ref val) = self.hash_data {
6077            {
6078                let b64 = encode_base64(val);
6079                start.push_attribute(("hashData", b64.as_str()));
6080            }
6081        }
6082        if let Some(ref val) = self.crypt_provider {
6083            start.push_attribute(("cryptProvider", val.as_str()));
6084        }
6085        if let Some(ref val) = self.alg_id_ext {
6086            {
6087                let s = val.to_string();
6088                start.push_attribute(("algIdExt", s.as_str()));
6089            }
6090        }
6091        if let Some(ref val) = self.alg_id_ext_source {
6092            start.push_attribute(("algIdExtSource", val.as_str()));
6093        }
6094        if let Some(ref val) = self.crypt_provider_type_ext {
6095            {
6096                let s = val.to_string();
6097                start.push_attribute(("cryptProviderTypeExt", s.as_str()));
6098            }
6099        }
6100        if let Some(ref val) = self.crypt_provider_type_ext_source {
6101            start.push_attribute(("cryptProviderTypeExtSource", val.as_str()));
6102        }
6103        #[cfg(feature = "extra-attrs")]
6104        for (key, value) in &self.extra_attrs {
6105            start.push_attribute((key.as_str(), value.as_str()));
6106        }
6107        start
6108    }
6109
6110    fn is_empty_element(&self) -> bool {
6111        true
6112    }
6113}
6114
6115impl ToXml for Presentation {
6116    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
6117        #[allow(unused_mut)]
6118        let mut start = start;
6119        #[cfg(feature = "pml-styling")]
6120        if let Some(ref val) = self.server_zoom {
6121            {
6122                let s = val.to_string();
6123                start.push_attribute(("serverZoom", s.as_str()));
6124            }
6125        }
6126        if let Some(ref val) = self.first_slide_num {
6127            {
6128                let s = val.to_string();
6129                start.push_attribute(("firstSlideNum", s.as_str()));
6130            }
6131        }
6132        #[cfg(feature = "pml-styling")]
6133        if let Some(ref val) = self.show_special_pls_on_title_sld {
6134            start.push_attribute(("showSpecialPlsOnTitleSld", if *val { "1" } else { "0" }));
6135        }
6136        #[cfg(feature = "pml-styling")]
6137        if let Some(ref val) = self.rtl {
6138            start.push_attribute(("rtl", if *val { "1" } else { "0" }));
6139        }
6140        if let Some(ref val) = self.remove_personal_info_on_save {
6141            start.push_attribute(("removePersonalInfoOnSave", if *val { "1" } else { "0" }));
6142        }
6143        if let Some(ref val) = self.compat_mode {
6144            start.push_attribute(("compatMode", if *val { "1" } else { "0" }));
6145        }
6146        #[cfg(feature = "pml-styling")]
6147        if let Some(ref val) = self.strict_first_and_last_chars {
6148            start.push_attribute(("strictFirstAndLastChars", if *val { "1" } else { "0" }));
6149        }
6150        #[cfg(feature = "pml-styling")]
6151        if let Some(ref val) = self.embed_true_type_fonts {
6152            start.push_attribute(("embedTrueTypeFonts", if *val { "1" } else { "0" }));
6153        }
6154        #[cfg(feature = "pml-styling")]
6155        if let Some(ref val) = self.save_subset_fonts {
6156            start.push_attribute(("saveSubsetFonts", if *val { "1" } else { "0" }));
6157        }
6158        #[cfg(feature = "pml-styling")]
6159        if let Some(ref val) = self.auto_compress_pictures {
6160            start.push_attribute(("autoCompressPictures", if *val { "1" } else { "0" }));
6161        }
6162        if let Some(ref val) = self.bookmark_id_seed {
6163            {
6164                let s = val.to_string();
6165                start.push_attribute(("bookmarkIdSeed", s.as_str()));
6166            }
6167        }
6168        if let Some(ref val) = self.conformance {
6169            {
6170                let s = val.to_string();
6171                start.push_attribute(("conformance", s.as_str()));
6172            }
6173        }
6174        #[cfg(feature = "extra-attrs")]
6175        for (key, value) in &self.extra_attrs {
6176            start.push_attribute((key.as_str(), value.as_str()));
6177        }
6178        start
6179    }
6180
6181    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
6182        #[cfg(feature = "extra-children")]
6183        let mut extra_iter = self.extra_children.iter().peekable();
6184        #[cfg(feature = "extra-children")]
6185        let mut emit_idx: usize = 0;
6186        #[cfg(feature = "extra-children")]
6187        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6188            extra_iter
6189                .next()
6190                .unwrap()
6191                .node
6192                .write_to(writer)
6193                .map_err(SerializeError::from)?;
6194        }
6195        if let Some(ref val) = self.sld_master_id_lst {
6196            val.write_element("p:sldMasterIdLst", writer)?;
6197        }
6198        #[cfg(feature = "extra-children")]
6199        {
6200            emit_idx += 1;
6201        }
6202        #[cfg(feature = "extra-children")]
6203        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6204            extra_iter
6205                .next()
6206                .unwrap()
6207                .node
6208                .write_to(writer)
6209                .map_err(SerializeError::from)?;
6210        }
6211        #[cfg(feature = "pml-notes")]
6212        if let Some(ref val) = self.notes_master_id_lst {
6213            val.write_element("p:notesMasterIdLst", writer)?;
6214        }
6215        #[cfg(feature = "extra-children")]
6216        {
6217            emit_idx += 1;
6218        }
6219        #[cfg(feature = "extra-children")]
6220        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6221            extra_iter
6222                .next()
6223                .unwrap()
6224                .node
6225                .write_to(writer)
6226                .map_err(SerializeError::from)?;
6227        }
6228        #[cfg(feature = "pml-masters")]
6229        if let Some(ref val) = self.handout_master_id_lst {
6230            val.write_element("p:handoutMasterIdLst", writer)?;
6231        }
6232        #[cfg(feature = "extra-children")]
6233        {
6234            emit_idx += 1;
6235        }
6236        #[cfg(feature = "extra-children")]
6237        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6238            extra_iter
6239                .next()
6240                .unwrap()
6241                .node
6242                .write_to(writer)
6243                .map_err(SerializeError::from)?;
6244        }
6245        if let Some(ref val) = self.sld_id_lst {
6246            val.write_element("p:sldIdLst", writer)?;
6247        }
6248        #[cfg(feature = "extra-children")]
6249        {
6250            emit_idx += 1;
6251        }
6252        #[cfg(feature = "extra-children")]
6253        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6254            extra_iter
6255                .next()
6256                .unwrap()
6257                .node
6258                .write_to(writer)
6259                .map_err(SerializeError::from)?;
6260        }
6261        if let Some(ref val) = self.sld_sz {
6262            val.write_element("p:sldSz", writer)?;
6263        }
6264        #[cfg(feature = "extra-children")]
6265        {
6266            emit_idx += 1;
6267        }
6268        #[cfg(feature = "extra-children")]
6269        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6270            extra_iter
6271                .next()
6272                .unwrap()
6273                .node
6274                .write_to(writer)
6275                .map_err(SerializeError::from)?;
6276        }
6277        #[cfg(feature = "pml-notes")]
6278        {
6279            let val = &self.notes_sz;
6280            val.write_element("p:notesSz", writer)?;
6281        }
6282        #[cfg(feature = "extra-children")]
6283        {
6284            emit_idx += 1;
6285        }
6286        #[cfg(feature = "extra-children")]
6287        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6288            extra_iter
6289                .next()
6290                .unwrap()
6291                .node
6292                .write_to(writer)
6293                .map_err(SerializeError::from)?;
6294        }
6295        #[cfg(feature = "pml-external")]
6296        if let Some(ref val) = self.smart_tags {
6297            val.write_element("p:smartTags", writer)?;
6298        }
6299        #[cfg(feature = "extra-children")]
6300        {
6301            emit_idx += 1;
6302        }
6303        #[cfg(feature = "extra-children")]
6304        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6305            extra_iter
6306                .next()
6307                .unwrap()
6308                .node
6309                .write_to(writer)
6310                .map_err(SerializeError::from)?;
6311        }
6312        #[cfg(feature = "pml-styling")]
6313        if let Some(ref val) = self.embedded_font_lst {
6314            val.write_element("p:embeddedFontLst", writer)?;
6315        }
6316        #[cfg(feature = "extra-children")]
6317        {
6318            emit_idx += 1;
6319        }
6320        #[cfg(feature = "extra-children")]
6321        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6322            extra_iter
6323                .next()
6324                .unwrap()
6325                .node
6326                .write_to(writer)
6327                .map_err(SerializeError::from)?;
6328        }
6329        if let Some(ref val) = self.cust_show_lst {
6330            val.write_element("p:custShowLst", writer)?;
6331        }
6332        #[cfg(feature = "extra-children")]
6333        {
6334            emit_idx += 1;
6335        }
6336        #[cfg(feature = "extra-children")]
6337        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6338            extra_iter
6339                .next()
6340                .unwrap()
6341                .node
6342                .write_to(writer)
6343                .map_err(SerializeError::from)?;
6344        }
6345        #[cfg(feature = "pml-media")]
6346        if let Some(ref val) = self.photo_album {
6347            val.write_element("p:photoAlbum", writer)?;
6348        }
6349        #[cfg(feature = "extra-children")]
6350        {
6351            emit_idx += 1;
6352        }
6353        #[cfg(feature = "extra-children")]
6354        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6355            extra_iter
6356                .next()
6357                .unwrap()
6358                .node
6359                .write_to(writer)
6360                .map_err(SerializeError::from)?;
6361        }
6362        #[cfg(feature = "pml-external")]
6363        if let Some(ref val) = self.cust_data_lst {
6364            val.write_element("p:custDataLst", writer)?;
6365        }
6366        #[cfg(feature = "extra-children")]
6367        {
6368            emit_idx += 1;
6369        }
6370        #[cfg(feature = "extra-children")]
6371        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6372            extra_iter
6373                .next()
6374                .unwrap()
6375                .node
6376                .write_to(writer)
6377                .map_err(SerializeError::from)?;
6378        }
6379        #[cfg(feature = "pml-styling")]
6380        if let Some(ref val) = self.kinsoku {
6381            val.write_element("p:kinsoku", writer)?;
6382        }
6383        #[cfg(feature = "extra-children")]
6384        {
6385            emit_idx += 1;
6386        }
6387        #[cfg(feature = "extra-children")]
6388        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6389            extra_iter
6390                .next()
6391                .unwrap()
6392                .node
6393                .write_to(writer)
6394                .map_err(SerializeError::from)?;
6395        }
6396        #[cfg(feature = "pml-styling")]
6397        if let Some(ref val) = self.default_text_style {
6398            val.write_element("p:defaultTextStyle", writer)?;
6399        }
6400        #[cfg(feature = "extra-children")]
6401        {
6402            emit_idx += 1;
6403        }
6404        #[cfg(feature = "extra-children")]
6405        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6406            extra_iter
6407                .next()
6408                .unwrap()
6409                .node
6410                .write_to(writer)
6411                .map_err(SerializeError::from)?;
6412        }
6413        if let Some(ref val) = self.modify_verifier {
6414            val.write_element("p:modifyVerifier", writer)?;
6415        }
6416        #[cfg(feature = "extra-children")]
6417        {
6418            emit_idx += 1;
6419        }
6420        #[cfg(feature = "extra-children")]
6421        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6422            extra_iter
6423                .next()
6424                .unwrap()
6425                .node
6426                .write_to(writer)
6427                .map_err(SerializeError::from)?;
6428        }
6429        #[cfg(feature = "pml-extensions")]
6430        if let Some(ref val) = self.ext_lst {
6431            val.write_element("p:extLst", writer)?;
6432        }
6433        #[cfg(feature = "extra-children")]
6434        {
6435            emit_idx += 1;
6436        }
6437        #[cfg(feature = "extra-children")]
6438        for extra in extra_iter {
6439            extra.node.write_to(writer).map_err(SerializeError::from)?;
6440        }
6441        Ok(())
6442    }
6443
6444    fn is_empty_element(&self) -> bool {
6445        if self.sld_master_id_lst.is_some() {
6446            return false;
6447        }
6448        #[cfg(feature = "pml-notes")]
6449        if self.notes_master_id_lst.is_some() {
6450            return false;
6451        }
6452        #[cfg(feature = "pml-masters")]
6453        if self.handout_master_id_lst.is_some() {
6454            return false;
6455        }
6456        if self.sld_id_lst.is_some() {
6457            return false;
6458        }
6459        if self.sld_sz.is_some() {
6460            return false;
6461        }
6462        #[cfg(feature = "pml-notes")]
6463        return false;
6464        #[cfg(feature = "pml-external")]
6465        if self.smart_tags.is_some() {
6466            return false;
6467        }
6468        #[cfg(feature = "pml-styling")]
6469        if self.embedded_font_lst.is_some() {
6470            return false;
6471        }
6472        if self.cust_show_lst.is_some() {
6473            return false;
6474        }
6475        #[cfg(feature = "pml-media")]
6476        if self.photo_album.is_some() {
6477            return false;
6478        }
6479        #[cfg(feature = "pml-external")]
6480        if self.cust_data_lst.is_some() {
6481            return false;
6482        }
6483        #[cfg(feature = "pml-styling")]
6484        if self.kinsoku.is_some() {
6485            return false;
6486        }
6487        #[cfg(feature = "pml-styling")]
6488        if self.default_text_style.is_some() {
6489            return false;
6490        }
6491        if self.modify_verifier.is_some() {
6492            return false;
6493        }
6494        #[cfg(feature = "pml-extensions")]
6495        if self.ext_lst.is_some() {
6496            return false;
6497        }
6498        #[cfg(feature = "extra-children")]
6499        if !self.extra_children.is_empty() {
6500            return false;
6501        }
6502        true
6503    }
6504}
6505
6506impl ToXml for CTHtmlPublishProperties {
6507    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
6508        #[allow(unused_mut)]
6509        let mut start = start;
6510        if let Some(ref val) = self.show_speaker_notes {
6511            start.push_attribute(("showSpeakerNotes", if *val { "1" } else { "0" }));
6512        }
6513        if let Some(ref val) = self.target {
6514            start.push_attribute(("target", val.as_str()));
6515        }
6516        if let Some(ref val) = self.title {
6517            start.push_attribute(("title", val.as_str()));
6518        }
6519        #[cfg(feature = "extra-attrs")]
6520        for (key, value) in &self.extra_attrs {
6521            start.push_attribute((key.as_str(), value.as_str()));
6522        }
6523        start
6524    }
6525
6526    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
6527        #[cfg(feature = "extra-children")]
6528        let mut extra_iter = self.extra_children.iter().peekable();
6529        #[cfg(feature = "extra-children")]
6530        let mut emit_idx: usize = 0;
6531        #[cfg(feature = "extra-children")]
6532        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6533            extra_iter
6534                .next()
6535                .unwrap()
6536                .node
6537                .write_to(writer)
6538                .map_err(SerializeError::from)?;
6539        }
6540        if let Some(ref val) = self.slide_list_choice {
6541            val.write_element("", writer)?;
6542        }
6543        #[cfg(feature = "extra-children")]
6544        {
6545            emit_idx += 1;
6546        }
6547        #[cfg(feature = "extra-children")]
6548        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6549            extra_iter
6550                .next()
6551                .unwrap()
6552                .node
6553                .write_to(writer)
6554                .map_err(SerializeError::from)?;
6555        }
6556        if let Some(ref val) = self.ext_lst {
6557            val.write_element("p:extLst", writer)?;
6558        }
6559        #[cfg(feature = "extra-children")]
6560        {
6561            emit_idx += 1;
6562        }
6563        #[cfg(feature = "extra-children")]
6564        for extra in extra_iter {
6565            extra.node.write_to(writer).map_err(SerializeError::from)?;
6566        }
6567        Ok(())
6568    }
6569
6570    fn is_empty_element(&self) -> bool {
6571        false
6572    }
6573}
6574
6575impl ToXml for CTWebProperties {
6576    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
6577        #[allow(unused_mut)]
6578        let mut start = start;
6579        if let Some(ref val) = self.show_animation {
6580            start.push_attribute(("showAnimation", if *val { "1" } else { "0" }));
6581        }
6582        if let Some(ref val) = self.resize_graphics {
6583            start.push_attribute(("resizeGraphics", if *val { "1" } else { "0" }));
6584        }
6585        if let Some(ref val) = self.allow_png {
6586            start.push_attribute(("allowPng", if *val { "1" } else { "0" }));
6587        }
6588        if let Some(ref val) = self.rely_on_vml {
6589            start.push_attribute(("relyOnVml", if *val { "1" } else { "0" }));
6590        }
6591        if let Some(ref val) = self.organize_in_folders {
6592            start.push_attribute(("organizeInFolders", if *val { "1" } else { "0" }));
6593        }
6594        if let Some(ref val) = self.use_long_filenames {
6595            start.push_attribute(("useLongFilenames", if *val { "1" } else { "0" }));
6596        }
6597        if let Some(ref val) = self.img_sz {
6598            {
6599                let s = val.to_string();
6600                start.push_attribute(("imgSz", s.as_str()));
6601            }
6602        }
6603        if let Some(ref val) = self.encoding {
6604            start.push_attribute(("encoding", val.as_str()));
6605        }
6606        if let Some(ref val) = self.clr {
6607            {
6608                let s = val.to_string();
6609                start.push_attribute(("clr", s.as_str()));
6610            }
6611        }
6612        #[cfg(feature = "extra-attrs")]
6613        for (key, value) in &self.extra_attrs {
6614            start.push_attribute((key.as_str(), value.as_str()));
6615        }
6616        start
6617    }
6618
6619    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
6620        #[cfg(feature = "extra-children")]
6621        let mut extra_iter = self.extra_children.iter().peekable();
6622        #[cfg(feature = "extra-children")]
6623        let mut emit_idx: usize = 0;
6624        #[cfg(feature = "extra-children")]
6625        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6626            extra_iter
6627                .next()
6628                .unwrap()
6629                .node
6630                .write_to(writer)
6631                .map_err(SerializeError::from)?;
6632        }
6633        if let Some(ref val) = self.ext_lst {
6634            val.write_element("p:extLst", writer)?;
6635        }
6636        #[cfg(feature = "extra-children")]
6637        {
6638            emit_idx += 1;
6639        }
6640        #[cfg(feature = "extra-children")]
6641        for extra in extra_iter {
6642            extra.node.write_to(writer).map_err(SerializeError::from)?;
6643        }
6644        Ok(())
6645    }
6646
6647    fn is_empty_element(&self) -> bool {
6648        if self.ext_lst.is_some() {
6649            return false;
6650        }
6651        #[cfg(feature = "extra-children")]
6652        if !self.extra_children.is_empty() {
6653            return false;
6654        }
6655        true
6656    }
6657}
6658
6659impl ToXml for CTPrintProperties {
6660    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
6661        #[allow(unused_mut)]
6662        let mut start = start;
6663        if let Some(ref val) = self.prn_what {
6664            {
6665                let s = val.to_string();
6666                start.push_attribute(("prnWhat", s.as_str()));
6667            }
6668        }
6669        if let Some(ref val) = self.clr_mode {
6670            {
6671                let s = val.to_string();
6672                start.push_attribute(("clrMode", s.as_str()));
6673            }
6674        }
6675        if let Some(ref val) = self.hidden_slides {
6676            start.push_attribute(("hiddenSlides", if *val { "1" } else { "0" }));
6677        }
6678        if let Some(ref val) = self.scale_to_fit_paper {
6679            start.push_attribute(("scaleToFitPaper", if *val { "1" } else { "0" }));
6680        }
6681        if let Some(ref val) = self.frame_slides {
6682            start.push_attribute(("frameSlides", if *val { "1" } else { "0" }));
6683        }
6684        #[cfg(feature = "extra-attrs")]
6685        for (key, value) in &self.extra_attrs {
6686            start.push_attribute((key.as_str(), value.as_str()));
6687        }
6688        start
6689    }
6690
6691    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
6692        #[cfg(feature = "extra-children")]
6693        let mut extra_iter = self.extra_children.iter().peekable();
6694        #[cfg(feature = "extra-children")]
6695        let mut emit_idx: usize = 0;
6696        #[cfg(feature = "extra-children")]
6697        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6698            extra_iter
6699                .next()
6700                .unwrap()
6701                .node
6702                .write_to(writer)
6703                .map_err(SerializeError::from)?;
6704        }
6705        if let Some(ref val) = self.ext_lst {
6706            val.write_element("p:extLst", writer)?;
6707        }
6708        #[cfg(feature = "extra-children")]
6709        {
6710            emit_idx += 1;
6711        }
6712        #[cfg(feature = "extra-children")]
6713        for extra in extra_iter {
6714            extra.node.write_to(writer).map_err(SerializeError::from)?;
6715        }
6716        Ok(())
6717    }
6718
6719    fn is_empty_element(&self) -> bool {
6720        if self.ext_lst.is_some() {
6721            return false;
6722        }
6723        #[cfg(feature = "extra-children")]
6724        if !self.extra_children.is_empty() {
6725            return false;
6726        }
6727        true
6728    }
6729}
6730
6731impl ToXml for CTShowInfoBrowse {
6732    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
6733        #[allow(unused_mut)]
6734        let mut start = start;
6735        if let Some(ref val) = self.show_scrollbar {
6736            start.push_attribute(("showScrollbar", if *val { "1" } else { "0" }));
6737        }
6738        #[cfg(feature = "extra-attrs")]
6739        for (key, value) in &self.extra_attrs {
6740            start.push_attribute((key.as_str(), value.as_str()));
6741        }
6742        start
6743    }
6744
6745    fn is_empty_element(&self) -> bool {
6746        true
6747    }
6748}
6749
6750impl ToXml for CTShowInfoKiosk {
6751    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
6752        #[allow(unused_mut)]
6753        let mut start = start;
6754        if let Some(ref val) = self.restart {
6755            {
6756                let s = val.to_string();
6757                start.push_attribute(("restart", s.as_str()));
6758            }
6759        }
6760        #[cfg(feature = "extra-attrs")]
6761        for (key, value) in &self.extra_attrs {
6762            start.push_attribute((key.as_str(), value.as_str()));
6763        }
6764        start
6765    }
6766
6767    fn is_empty_element(&self) -> bool {
6768        true
6769    }
6770}
6771
6772impl ToXml for EGShowType {
6773    fn write_element<W: Write>(
6774        &self,
6775        _tag: &str,
6776        writer: &mut Writer<W>,
6777    ) -> Result<(), SerializeError> {
6778        match self {
6779            Self::Present(inner) => inner.write_element("p:present", writer)?,
6780            Self::Browse(inner) => inner.write_element("p:browse", writer)?,
6781            Self::Kiosk(inner) => inner.write_element("p:kiosk", writer)?,
6782        }
6783        Ok(())
6784    }
6785}
6786
6787impl ToXml for CTShowProperties {
6788    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
6789        #[allow(unused_mut)]
6790        let mut start = start;
6791        if let Some(ref val) = self.r#loop {
6792            start.push_attribute(("loop", if *val { "1" } else { "0" }));
6793        }
6794        if let Some(ref val) = self.show_narration {
6795            start.push_attribute(("showNarration", if *val { "1" } else { "0" }));
6796        }
6797        if let Some(ref val) = self.show_animation {
6798            start.push_attribute(("showAnimation", if *val { "1" } else { "0" }));
6799        }
6800        if let Some(ref val) = self.use_timings {
6801            start.push_attribute(("useTimings", if *val { "1" } else { "0" }));
6802        }
6803        #[cfg(feature = "extra-attrs")]
6804        for (key, value) in &self.extra_attrs {
6805            start.push_attribute((key.as_str(), value.as_str()));
6806        }
6807        start
6808    }
6809
6810    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
6811        #[cfg(feature = "extra-children")]
6812        let mut extra_iter = self.extra_children.iter().peekable();
6813        #[cfg(feature = "extra-children")]
6814        let mut emit_idx: usize = 0;
6815        #[cfg(feature = "extra-children")]
6816        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6817            extra_iter
6818                .next()
6819                .unwrap()
6820                .node
6821                .write_to(writer)
6822                .map_err(SerializeError::from)?;
6823        }
6824        if let Some(ref val) = self.show_type {
6825            val.write_element("", writer)?;
6826        }
6827        #[cfg(feature = "extra-children")]
6828        {
6829            emit_idx += 1;
6830        }
6831        #[cfg(feature = "extra-children")]
6832        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6833            extra_iter
6834                .next()
6835                .unwrap()
6836                .node
6837                .write_to(writer)
6838                .map_err(SerializeError::from)?;
6839        }
6840        if let Some(ref val) = self.slide_list_choice {
6841            val.write_element("", writer)?;
6842        }
6843        #[cfg(feature = "extra-children")]
6844        {
6845            emit_idx += 1;
6846        }
6847        #[cfg(feature = "extra-children")]
6848        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6849            extra_iter
6850                .next()
6851                .unwrap()
6852                .node
6853                .write_to(writer)
6854                .map_err(SerializeError::from)?;
6855        }
6856        if let Some(ref val) = self.pen_clr {
6857            val.write_element("p:penClr", writer)?;
6858        }
6859        #[cfg(feature = "extra-children")]
6860        {
6861            emit_idx += 1;
6862        }
6863        #[cfg(feature = "extra-children")]
6864        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6865            extra_iter
6866                .next()
6867                .unwrap()
6868                .node
6869                .write_to(writer)
6870                .map_err(SerializeError::from)?;
6871        }
6872        if let Some(ref val) = self.ext_lst {
6873            val.write_element("p:extLst", writer)?;
6874        }
6875        #[cfg(feature = "extra-children")]
6876        {
6877            emit_idx += 1;
6878        }
6879        #[cfg(feature = "extra-children")]
6880        for extra in extra_iter {
6881            extra.node.write_to(writer).map_err(SerializeError::from)?;
6882        }
6883        Ok(())
6884    }
6885
6886    fn is_empty_element(&self) -> bool {
6887        if self.show_type.is_some() {
6888            return false;
6889        }
6890        if self.slide_list_choice.is_some() {
6891            return false;
6892        }
6893        if self.pen_clr.is_some() {
6894            return false;
6895        }
6896        if self.ext_lst.is_some() {
6897            return false;
6898        }
6899        #[cfg(feature = "extra-children")]
6900        if !self.extra_children.is_empty() {
6901            return false;
6902        }
6903        true
6904    }
6905}
6906
6907impl ToXml for CTPresentationProperties {
6908    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
6909        #[cfg(feature = "extra-children")]
6910        let mut extra_iter = self.extra_children.iter().peekable();
6911        #[cfg(feature = "extra-children")]
6912        let mut emit_idx: usize = 0;
6913        #[cfg(feature = "extra-children")]
6914        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6915            extra_iter
6916                .next()
6917                .unwrap()
6918                .node
6919                .write_to(writer)
6920                .map_err(SerializeError::from)?;
6921        }
6922        #[cfg(feature = "pml-external")]
6923        if let Some(ref val) = self.html_pub_pr {
6924            val.write_element("p:htmlPubPr", writer)?;
6925        }
6926        #[cfg(feature = "extra-children")]
6927        {
6928            emit_idx += 1;
6929        }
6930        #[cfg(feature = "extra-children")]
6931        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6932            extra_iter
6933                .next()
6934                .unwrap()
6935                .node
6936                .write_to(writer)
6937                .map_err(SerializeError::from)?;
6938        }
6939        #[cfg(feature = "pml-external")]
6940        if let Some(ref val) = self.web_pr {
6941            val.write_element("p:webPr", writer)?;
6942        }
6943        #[cfg(feature = "extra-children")]
6944        {
6945            emit_idx += 1;
6946        }
6947        #[cfg(feature = "extra-children")]
6948        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6949            extra_iter
6950                .next()
6951                .unwrap()
6952                .node
6953                .write_to(writer)
6954                .map_err(SerializeError::from)?;
6955        }
6956        if let Some(ref val) = self.prn_pr {
6957            val.write_element("p:prnPr", writer)?;
6958        }
6959        #[cfg(feature = "extra-children")]
6960        {
6961            emit_idx += 1;
6962        }
6963        #[cfg(feature = "extra-children")]
6964        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6965            extra_iter
6966                .next()
6967                .unwrap()
6968                .node
6969                .write_to(writer)
6970                .map_err(SerializeError::from)?;
6971        }
6972        if let Some(ref val) = self.show_pr {
6973            val.write_element("p:showPr", writer)?;
6974        }
6975        #[cfg(feature = "extra-children")]
6976        {
6977            emit_idx += 1;
6978        }
6979        #[cfg(feature = "extra-children")]
6980        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6981            extra_iter
6982                .next()
6983                .unwrap()
6984                .node
6985                .write_to(writer)
6986                .map_err(SerializeError::from)?;
6987        }
6988        #[cfg(feature = "pml-styling")]
6989        if let Some(ref val) = self.clr_mru {
6990            val.write_element("p:clrMru", writer)?;
6991        }
6992        #[cfg(feature = "extra-children")]
6993        {
6994            emit_idx += 1;
6995        }
6996        #[cfg(feature = "extra-children")]
6997        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
6998            extra_iter
6999                .next()
7000                .unwrap()
7001                .node
7002                .write_to(writer)
7003                .map_err(SerializeError::from)?;
7004        }
7005        #[cfg(feature = "pml-extensions")]
7006        if let Some(ref val) = self.ext_lst {
7007            val.write_element("p:extLst", writer)?;
7008        }
7009        #[cfg(feature = "extra-children")]
7010        {
7011            emit_idx += 1;
7012        }
7013        #[cfg(feature = "extra-children")]
7014        for extra in extra_iter {
7015            extra.node.write_to(writer).map_err(SerializeError::from)?;
7016        }
7017        Ok(())
7018    }
7019
7020    fn is_empty_element(&self) -> bool {
7021        #[cfg(feature = "pml-external")]
7022        if self.html_pub_pr.is_some() {
7023            return false;
7024        }
7025        #[cfg(feature = "pml-external")]
7026        if self.web_pr.is_some() {
7027            return false;
7028        }
7029        if self.prn_pr.is_some() {
7030            return false;
7031        }
7032        if self.show_pr.is_some() {
7033            return false;
7034        }
7035        #[cfg(feature = "pml-styling")]
7036        if self.clr_mru.is_some() {
7037            return false;
7038        }
7039        #[cfg(feature = "pml-extensions")]
7040        if self.ext_lst.is_some() {
7041            return false;
7042        }
7043        #[cfg(feature = "extra-children")]
7044        if !self.extra_children.is_empty() {
7045            return false;
7046        }
7047        true
7048    }
7049}
7050
7051impl ToXml for CTHeaderFooter {
7052    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
7053        #[allow(unused_mut)]
7054        let mut start = start;
7055        #[cfg(feature = "pml-masters")]
7056        if let Some(ref val) = self.sld_num {
7057            start.push_attribute(("sldNum", if *val { "1" } else { "0" }));
7058        }
7059        #[cfg(feature = "pml-masters")]
7060        if let Some(ref val) = self.hdr {
7061            start.push_attribute(("hdr", if *val { "1" } else { "0" }));
7062        }
7063        #[cfg(feature = "pml-masters")]
7064        if let Some(ref val) = self.ftr {
7065            start.push_attribute(("ftr", if *val { "1" } else { "0" }));
7066        }
7067        #[cfg(feature = "pml-masters")]
7068        if let Some(ref val) = self.dt {
7069            start.push_attribute(("dt", if *val { "1" } else { "0" }));
7070        }
7071        #[cfg(feature = "extra-attrs")]
7072        for (key, value) in &self.extra_attrs {
7073            start.push_attribute((key.as_str(), value.as_str()));
7074        }
7075        start
7076    }
7077
7078    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
7079        #[cfg(feature = "extra-children")]
7080        let mut extra_iter = self.extra_children.iter().peekable();
7081        #[cfg(feature = "extra-children")]
7082        let mut emit_idx: usize = 0;
7083        #[cfg(feature = "extra-children")]
7084        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7085            extra_iter
7086                .next()
7087                .unwrap()
7088                .node
7089                .write_to(writer)
7090                .map_err(SerializeError::from)?;
7091        }
7092        if let Some(ref val) = self.ext_lst {
7093            val.write_element("p:extLst", writer)?;
7094        }
7095        #[cfg(feature = "extra-children")]
7096        {
7097            emit_idx += 1;
7098        }
7099        #[cfg(feature = "extra-children")]
7100        for extra in extra_iter {
7101            extra.node.write_to(writer).map_err(SerializeError::from)?;
7102        }
7103        Ok(())
7104    }
7105
7106    fn is_empty_element(&self) -> bool {
7107        if self.ext_lst.is_some() {
7108            return false;
7109        }
7110        #[cfg(feature = "extra-children")]
7111        if !self.extra_children.is_empty() {
7112            return false;
7113        }
7114        true
7115    }
7116}
7117
7118impl ToXml for CTPlaceholder {
7119    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
7120        #[allow(unused_mut)]
7121        let mut start = start;
7122        if let Some(ref val) = self.r#type {
7123            {
7124                let s = val.to_string();
7125                start.push_attribute(("type", s.as_str()));
7126            }
7127        }
7128        if let Some(ref val) = self.orient {
7129            {
7130                let s = val.to_string();
7131                start.push_attribute(("orient", s.as_str()));
7132            }
7133        }
7134        if let Some(ref val) = self.sz {
7135            {
7136                let s = val.to_string();
7137                start.push_attribute(("sz", s.as_str()));
7138            }
7139        }
7140        if let Some(ref val) = self.idx {
7141            {
7142                let s = val.to_string();
7143                start.push_attribute(("idx", s.as_str()));
7144            }
7145        }
7146        if let Some(ref val) = self.has_custom_prompt {
7147            start.push_attribute(("hasCustomPrompt", if *val { "1" } else { "0" }));
7148        }
7149        #[cfg(feature = "extra-attrs")]
7150        for (key, value) in &self.extra_attrs {
7151            start.push_attribute((key.as_str(), value.as_str()));
7152        }
7153        start
7154    }
7155
7156    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
7157        #[cfg(feature = "extra-children")]
7158        let mut extra_iter = self.extra_children.iter().peekable();
7159        #[cfg(feature = "extra-children")]
7160        let mut emit_idx: usize = 0;
7161        #[cfg(feature = "extra-children")]
7162        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7163            extra_iter
7164                .next()
7165                .unwrap()
7166                .node
7167                .write_to(writer)
7168                .map_err(SerializeError::from)?;
7169        }
7170        if let Some(ref val) = self.ext_lst {
7171            val.write_element("p:extLst", writer)?;
7172        }
7173        #[cfg(feature = "extra-children")]
7174        {
7175            emit_idx += 1;
7176        }
7177        #[cfg(feature = "extra-children")]
7178        for extra in extra_iter {
7179            extra.node.write_to(writer).map_err(SerializeError::from)?;
7180        }
7181        Ok(())
7182    }
7183
7184    fn is_empty_element(&self) -> bool {
7185        if self.ext_lst.is_some() {
7186            return false;
7187        }
7188        #[cfg(feature = "extra-children")]
7189        if !self.extra_children.is_empty() {
7190            return false;
7191        }
7192        true
7193    }
7194}
7195
7196impl ToXml for CTApplicationNonVisualDrawingProps {
7197    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
7198        #[allow(unused_mut)]
7199        let mut start = start;
7200        if let Some(ref val) = self.is_photo {
7201            start.push_attribute(("isPhoto", if *val { "1" } else { "0" }));
7202        }
7203        if let Some(ref val) = self.user_drawn {
7204            start.push_attribute(("userDrawn", if *val { "1" } else { "0" }));
7205        }
7206        #[cfg(feature = "extra-attrs")]
7207        for (key, value) in &self.extra_attrs {
7208            start.push_attribute((key.as_str(), value.as_str()));
7209        }
7210        start
7211    }
7212
7213    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
7214        #[cfg(feature = "extra-children")]
7215        let mut extra_iter = self.extra_children.iter().peekable();
7216        #[cfg(feature = "extra-children")]
7217        let mut emit_idx: usize = 0;
7218        #[cfg(feature = "extra-children")]
7219        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7220            extra_iter
7221                .next()
7222                .unwrap()
7223                .node
7224                .write_to(writer)
7225                .map_err(SerializeError::from)?;
7226        }
7227        if let Some(ref val) = self.ph {
7228            val.write_element("p:ph", writer)?;
7229        }
7230        #[cfg(feature = "extra-children")]
7231        {
7232            emit_idx += 1;
7233        }
7234        #[cfg(feature = "extra-children")]
7235        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7236            extra_iter
7237                .next()
7238                .unwrap()
7239                .node
7240                .write_to(writer)
7241                .map_err(SerializeError::from)?;
7242        }
7243        if let Some(ref val) = self.cust_data_lst {
7244            val.write_element("p:custDataLst", writer)?;
7245        }
7246        #[cfg(feature = "extra-children")]
7247        {
7248            emit_idx += 1;
7249        }
7250        #[cfg(feature = "extra-children")]
7251        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7252            extra_iter
7253                .next()
7254                .unwrap()
7255                .node
7256                .write_to(writer)
7257                .map_err(SerializeError::from)?;
7258        }
7259        if let Some(ref val) = self.ext_lst {
7260            val.write_element("p:extLst", writer)?;
7261        }
7262        #[cfg(feature = "extra-children")]
7263        {
7264            emit_idx += 1;
7265        }
7266        #[cfg(feature = "extra-children")]
7267        for extra in extra_iter {
7268            extra.node.write_to(writer).map_err(SerializeError::from)?;
7269        }
7270        Ok(())
7271    }
7272
7273    fn is_empty_element(&self) -> bool {
7274        if self.ph.is_some() {
7275            return false;
7276        }
7277        if self.cust_data_lst.is_some() {
7278            return false;
7279        }
7280        if self.ext_lst.is_some() {
7281            return false;
7282        }
7283        #[cfg(feature = "extra-children")]
7284        if !self.extra_children.is_empty() {
7285            return false;
7286        }
7287        true
7288    }
7289}
7290
7291impl ToXml for ShapeNonVisual {
7292    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
7293        #[cfg(feature = "extra-children")]
7294        let mut extra_iter = self.extra_children.iter().peekable();
7295        #[cfg(feature = "extra-children")]
7296        let mut emit_idx: usize = 0;
7297        #[cfg(feature = "extra-children")]
7298        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7299            extra_iter
7300                .next()
7301                .unwrap()
7302                .node
7303                .write_to(writer)
7304                .map_err(SerializeError::from)?;
7305        }
7306        {
7307            let val = &self.c_nv_pr;
7308            val.write_element("p:cNvPr", writer)?;
7309        }
7310        #[cfg(feature = "extra-children")]
7311        {
7312            emit_idx += 1;
7313        }
7314        #[cfg(feature = "extra-children")]
7315        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7316            extra_iter
7317                .next()
7318                .unwrap()
7319                .node
7320                .write_to(writer)
7321                .map_err(SerializeError::from)?;
7322        }
7323        {
7324            let val = &self.c_nv_sp_pr;
7325            val.write_element("p:cNvSpPr", writer)?;
7326        }
7327        #[cfg(feature = "extra-children")]
7328        {
7329            emit_idx += 1;
7330        }
7331        #[cfg(feature = "extra-children")]
7332        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7333            extra_iter
7334                .next()
7335                .unwrap()
7336                .node
7337                .write_to(writer)
7338                .map_err(SerializeError::from)?;
7339        }
7340        {
7341            let val = &self.nv_pr;
7342            val.write_element("p:nvPr", writer)?;
7343        }
7344        #[cfg(feature = "extra-children")]
7345        {
7346            emit_idx += 1;
7347        }
7348        #[cfg(feature = "extra-children")]
7349        for extra in extra_iter {
7350            extra.node.write_to(writer).map_err(SerializeError::from)?;
7351        }
7352        Ok(())
7353    }
7354
7355    fn is_empty_element(&self) -> bool {
7356        false
7357    }
7358}
7359
7360impl ToXml for Shape {
7361    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
7362        #[allow(unused_mut)]
7363        let mut start = start;
7364        #[cfg(feature = "pml-styling")]
7365        if let Some(ref val) = self.use_bg_fill {
7366            start.push_attribute(("useBgFill", if *val { "1" } else { "0" }));
7367        }
7368        #[cfg(feature = "extra-attrs")]
7369        for (key, value) in &self.extra_attrs {
7370            start.push_attribute((key.as_str(), value.as_str()));
7371        }
7372        start
7373    }
7374
7375    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
7376        #[cfg(feature = "extra-children")]
7377        let mut extra_iter = self.extra_children.iter().peekable();
7378        #[cfg(feature = "extra-children")]
7379        let mut emit_idx: usize = 0;
7380        #[cfg(feature = "extra-children")]
7381        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7382            extra_iter
7383                .next()
7384                .unwrap()
7385                .node
7386                .write_to(writer)
7387                .map_err(SerializeError::from)?;
7388        }
7389        {
7390            let val = &self.non_visual_properties;
7391            val.write_element("p:nvSpPr", writer)?;
7392        }
7393        #[cfg(feature = "extra-children")]
7394        {
7395            emit_idx += 1;
7396        }
7397        #[cfg(feature = "extra-children")]
7398        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7399            extra_iter
7400                .next()
7401                .unwrap()
7402                .node
7403                .write_to(writer)
7404                .map_err(SerializeError::from)?;
7405        }
7406        {
7407            let val = &self.shape_properties;
7408            val.write_element("p:spPr", writer)?;
7409        }
7410        #[cfg(feature = "extra-children")]
7411        {
7412            emit_idx += 1;
7413        }
7414        #[cfg(feature = "extra-children")]
7415        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7416            extra_iter
7417                .next()
7418                .unwrap()
7419                .node
7420                .write_to(writer)
7421                .map_err(SerializeError::from)?;
7422        }
7423        #[cfg(feature = "pml-styling")]
7424        if let Some(ref val) = self.style {
7425            val.write_element("p:style", writer)?;
7426        }
7427        #[cfg(feature = "extra-children")]
7428        {
7429            emit_idx += 1;
7430        }
7431        #[cfg(feature = "extra-children")]
7432        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7433            extra_iter
7434                .next()
7435                .unwrap()
7436                .node
7437                .write_to(writer)
7438                .map_err(SerializeError::from)?;
7439        }
7440        if let Some(ref val) = self.text_body {
7441            val.write_element("p:txBody", writer)?;
7442        }
7443        #[cfg(feature = "extra-children")]
7444        {
7445            emit_idx += 1;
7446        }
7447        #[cfg(feature = "extra-children")]
7448        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7449            extra_iter
7450                .next()
7451                .unwrap()
7452                .node
7453                .write_to(writer)
7454                .map_err(SerializeError::from)?;
7455        }
7456        #[cfg(feature = "pml-extensions")]
7457        if let Some(ref val) = self.ext_lst {
7458            val.write_element("p:extLst", writer)?;
7459        }
7460        #[cfg(feature = "extra-children")]
7461        {
7462            emit_idx += 1;
7463        }
7464        #[cfg(feature = "extra-children")]
7465        for extra in extra_iter {
7466            extra.node.write_to(writer).map_err(SerializeError::from)?;
7467        }
7468        Ok(())
7469    }
7470
7471    fn is_empty_element(&self) -> bool {
7472        false
7473    }
7474}
7475
7476impl ToXml for CTConnectorNonVisual {
7477    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
7478        #[cfg(feature = "extra-children")]
7479        let mut extra_iter = self.extra_children.iter().peekable();
7480        #[cfg(feature = "extra-children")]
7481        let mut emit_idx: usize = 0;
7482        #[cfg(feature = "extra-children")]
7483        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7484            extra_iter
7485                .next()
7486                .unwrap()
7487                .node
7488                .write_to(writer)
7489                .map_err(SerializeError::from)?;
7490        }
7491        {
7492            let val = &self.c_nv_pr;
7493            val.write_element("p:cNvPr", writer)?;
7494        }
7495        #[cfg(feature = "extra-children")]
7496        {
7497            emit_idx += 1;
7498        }
7499        #[cfg(feature = "extra-children")]
7500        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7501            extra_iter
7502                .next()
7503                .unwrap()
7504                .node
7505                .write_to(writer)
7506                .map_err(SerializeError::from)?;
7507        }
7508        {
7509            let val = &self.c_nv_cxn_sp_pr;
7510            val.write_element("p:cNvCxnSpPr", writer)?;
7511        }
7512        #[cfg(feature = "extra-children")]
7513        {
7514            emit_idx += 1;
7515        }
7516        #[cfg(feature = "extra-children")]
7517        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7518            extra_iter
7519                .next()
7520                .unwrap()
7521                .node
7522                .write_to(writer)
7523                .map_err(SerializeError::from)?;
7524        }
7525        {
7526            let val = &self.nv_pr;
7527            val.write_element("p:nvPr", writer)?;
7528        }
7529        #[cfg(feature = "extra-children")]
7530        {
7531            emit_idx += 1;
7532        }
7533        #[cfg(feature = "extra-children")]
7534        for extra in extra_iter {
7535            extra.node.write_to(writer).map_err(SerializeError::from)?;
7536        }
7537        Ok(())
7538    }
7539
7540    fn is_empty_element(&self) -> bool {
7541        false
7542    }
7543}
7544
7545impl ToXml for Connector {
7546    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
7547        #[cfg(feature = "extra-children")]
7548        let mut extra_iter = self.extra_children.iter().peekable();
7549        #[cfg(feature = "extra-children")]
7550        let mut emit_idx: usize = 0;
7551        #[cfg(feature = "extra-children")]
7552        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7553            extra_iter
7554                .next()
7555                .unwrap()
7556                .node
7557                .write_to(writer)
7558                .map_err(SerializeError::from)?;
7559        }
7560        {
7561            let val = &self.non_visual_connector_properties;
7562            val.write_element("p:nvCxnSpPr", writer)?;
7563        }
7564        #[cfg(feature = "extra-children")]
7565        {
7566            emit_idx += 1;
7567        }
7568        #[cfg(feature = "extra-children")]
7569        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7570            extra_iter
7571                .next()
7572                .unwrap()
7573                .node
7574                .write_to(writer)
7575                .map_err(SerializeError::from)?;
7576        }
7577        {
7578            let val = &self.shape_properties;
7579            val.write_element("p:spPr", writer)?;
7580        }
7581        #[cfg(feature = "extra-children")]
7582        {
7583            emit_idx += 1;
7584        }
7585        #[cfg(feature = "extra-children")]
7586        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7587            extra_iter
7588                .next()
7589                .unwrap()
7590                .node
7591                .write_to(writer)
7592                .map_err(SerializeError::from)?;
7593        }
7594        #[cfg(feature = "pml-styling")]
7595        if let Some(ref val) = self.style {
7596            val.write_element("p:style", writer)?;
7597        }
7598        #[cfg(feature = "extra-children")]
7599        {
7600            emit_idx += 1;
7601        }
7602        #[cfg(feature = "extra-children")]
7603        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7604            extra_iter
7605                .next()
7606                .unwrap()
7607                .node
7608                .write_to(writer)
7609                .map_err(SerializeError::from)?;
7610        }
7611        #[cfg(feature = "pml-extensions")]
7612        if let Some(ref val) = self.ext_lst {
7613            val.write_element("p:extLst", writer)?;
7614        }
7615        #[cfg(feature = "extra-children")]
7616        {
7617            emit_idx += 1;
7618        }
7619        #[cfg(feature = "extra-children")]
7620        for extra in extra_iter {
7621            extra.node.write_to(writer).map_err(SerializeError::from)?;
7622        }
7623        Ok(())
7624    }
7625
7626    fn is_empty_element(&self) -> bool {
7627        false
7628    }
7629}
7630
7631impl ToXml for CTPictureNonVisual {
7632    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
7633        #[cfg(feature = "extra-children")]
7634        let mut extra_iter = self.extra_children.iter().peekable();
7635        #[cfg(feature = "extra-children")]
7636        let mut emit_idx: usize = 0;
7637        #[cfg(feature = "extra-children")]
7638        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7639            extra_iter
7640                .next()
7641                .unwrap()
7642                .node
7643                .write_to(writer)
7644                .map_err(SerializeError::from)?;
7645        }
7646        {
7647            let val = &self.c_nv_pr;
7648            val.write_element("p:cNvPr", writer)?;
7649        }
7650        #[cfg(feature = "extra-children")]
7651        {
7652            emit_idx += 1;
7653        }
7654        #[cfg(feature = "extra-children")]
7655        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7656            extra_iter
7657                .next()
7658                .unwrap()
7659                .node
7660                .write_to(writer)
7661                .map_err(SerializeError::from)?;
7662        }
7663        {
7664            let val = &self.c_nv_pic_pr;
7665            val.write_element("p:cNvPicPr", writer)?;
7666        }
7667        #[cfg(feature = "extra-children")]
7668        {
7669            emit_idx += 1;
7670        }
7671        #[cfg(feature = "extra-children")]
7672        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7673            extra_iter
7674                .next()
7675                .unwrap()
7676                .node
7677                .write_to(writer)
7678                .map_err(SerializeError::from)?;
7679        }
7680        {
7681            let val = &self.nv_pr;
7682            val.write_element("p:nvPr", writer)?;
7683        }
7684        #[cfg(feature = "extra-children")]
7685        {
7686            emit_idx += 1;
7687        }
7688        #[cfg(feature = "extra-children")]
7689        for extra in extra_iter {
7690            extra.node.write_to(writer).map_err(SerializeError::from)?;
7691        }
7692        Ok(())
7693    }
7694
7695    fn is_empty_element(&self) -> bool {
7696        false
7697    }
7698}
7699
7700impl ToXml for Picture {
7701    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
7702        #[cfg(feature = "extra-children")]
7703        let mut extra_iter = self.extra_children.iter().peekable();
7704        #[cfg(feature = "extra-children")]
7705        let mut emit_idx: usize = 0;
7706        #[cfg(feature = "extra-children")]
7707        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7708            extra_iter
7709                .next()
7710                .unwrap()
7711                .node
7712                .write_to(writer)
7713                .map_err(SerializeError::from)?;
7714        }
7715        {
7716            let val = &self.non_visual_picture_properties;
7717            val.write_element("p:nvPicPr", writer)?;
7718        }
7719        #[cfg(feature = "extra-children")]
7720        {
7721            emit_idx += 1;
7722        }
7723        #[cfg(feature = "extra-children")]
7724        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7725            extra_iter
7726                .next()
7727                .unwrap()
7728                .node
7729                .write_to(writer)
7730                .map_err(SerializeError::from)?;
7731        }
7732        {
7733            let val = &self.blip_fill;
7734            val.write_element("p:blipFill", writer)?;
7735        }
7736        #[cfg(feature = "extra-children")]
7737        {
7738            emit_idx += 1;
7739        }
7740        #[cfg(feature = "extra-children")]
7741        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7742            extra_iter
7743                .next()
7744                .unwrap()
7745                .node
7746                .write_to(writer)
7747                .map_err(SerializeError::from)?;
7748        }
7749        {
7750            let val = &self.shape_properties;
7751            val.write_element("p:spPr", writer)?;
7752        }
7753        #[cfg(feature = "extra-children")]
7754        {
7755            emit_idx += 1;
7756        }
7757        #[cfg(feature = "extra-children")]
7758        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7759            extra_iter
7760                .next()
7761                .unwrap()
7762                .node
7763                .write_to(writer)
7764                .map_err(SerializeError::from)?;
7765        }
7766        #[cfg(feature = "pml-styling")]
7767        if let Some(ref val) = self.style {
7768            val.write_element("p:style", writer)?;
7769        }
7770        #[cfg(feature = "extra-children")]
7771        {
7772            emit_idx += 1;
7773        }
7774        #[cfg(feature = "extra-children")]
7775        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7776            extra_iter
7777                .next()
7778                .unwrap()
7779                .node
7780                .write_to(writer)
7781                .map_err(SerializeError::from)?;
7782        }
7783        #[cfg(feature = "pml-extensions")]
7784        if let Some(ref val) = self.ext_lst {
7785            val.write_element("p:extLst", writer)?;
7786        }
7787        #[cfg(feature = "extra-children")]
7788        {
7789            emit_idx += 1;
7790        }
7791        #[cfg(feature = "extra-children")]
7792        for extra in extra_iter {
7793            extra.node.write_to(writer).map_err(SerializeError::from)?;
7794        }
7795        Ok(())
7796    }
7797
7798    fn is_empty_element(&self) -> bool {
7799        false
7800    }
7801}
7802
7803impl ToXml for CTGraphicalObjectFrameNonVisual {
7804    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
7805        #[cfg(feature = "extra-children")]
7806        let mut extra_iter = self.extra_children.iter().peekable();
7807        #[cfg(feature = "extra-children")]
7808        let mut emit_idx: usize = 0;
7809        #[cfg(feature = "extra-children")]
7810        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7811            extra_iter
7812                .next()
7813                .unwrap()
7814                .node
7815                .write_to(writer)
7816                .map_err(SerializeError::from)?;
7817        }
7818        {
7819            let val = &self.c_nv_pr;
7820            val.write_element("p:cNvPr", writer)?;
7821        }
7822        #[cfg(feature = "extra-children")]
7823        {
7824            emit_idx += 1;
7825        }
7826        #[cfg(feature = "extra-children")]
7827        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7828            extra_iter
7829                .next()
7830                .unwrap()
7831                .node
7832                .write_to(writer)
7833                .map_err(SerializeError::from)?;
7834        }
7835        {
7836            let val = &self.c_nv_graphic_frame_pr;
7837            val.write_element("p:cNvGraphicFramePr", writer)?;
7838        }
7839        #[cfg(feature = "extra-children")]
7840        {
7841            emit_idx += 1;
7842        }
7843        #[cfg(feature = "extra-children")]
7844        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7845            extra_iter
7846                .next()
7847                .unwrap()
7848                .node
7849                .write_to(writer)
7850                .map_err(SerializeError::from)?;
7851        }
7852        {
7853            let val = &self.nv_pr;
7854            val.write_element("p:nvPr", writer)?;
7855        }
7856        #[cfg(feature = "extra-children")]
7857        {
7858            emit_idx += 1;
7859        }
7860        #[cfg(feature = "extra-children")]
7861        for extra in extra_iter {
7862            extra.node.write_to(writer).map_err(SerializeError::from)?;
7863        }
7864        Ok(())
7865    }
7866
7867    fn is_empty_element(&self) -> bool {
7868        false
7869    }
7870}
7871
7872impl ToXml for GraphicalObjectFrame {
7873    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
7874        #[allow(unused_mut)]
7875        let mut start = start;
7876        #[cfg(feature = "pml-styling")]
7877        if let Some(ref val) = self.bw_mode {
7878            {
7879                let s = val.to_string();
7880                start.push_attribute(("bwMode", s.as_str()));
7881            }
7882        }
7883        #[cfg(feature = "extra-attrs")]
7884        for (key, value) in &self.extra_attrs {
7885            start.push_attribute((key.as_str(), value.as_str()));
7886        }
7887        start
7888    }
7889
7890    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
7891        #[cfg(feature = "extra-children")]
7892        let mut extra_iter = self.extra_children.iter().peekable();
7893        #[cfg(feature = "extra-children")]
7894        let mut emit_idx: usize = 0;
7895        #[cfg(feature = "extra-children")]
7896        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7897            extra_iter
7898                .next()
7899                .unwrap()
7900                .node
7901                .write_to(writer)
7902                .map_err(SerializeError::from)?;
7903        }
7904        {
7905            let val = &self.nv_graphic_frame_pr;
7906            val.write_element("p:nvGraphicFramePr", writer)?;
7907        }
7908        #[cfg(feature = "extra-children")]
7909        {
7910            emit_idx += 1;
7911        }
7912        #[cfg(feature = "extra-children")]
7913        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7914            extra_iter
7915                .next()
7916                .unwrap()
7917                .node
7918                .write_to(writer)
7919                .map_err(SerializeError::from)?;
7920        }
7921        {
7922            let val = &self.xfrm;
7923            val.write_element("p:xfrm", writer)?;
7924        }
7925        #[cfg(feature = "extra-children")]
7926        {
7927            emit_idx += 1;
7928        }
7929        #[cfg(feature = "extra-children")]
7930        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7931            extra_iter
7932                .next()
7933                .unwrap()
7934                .node
7935                .write_to(writer)
7936                .map_err(SerializeError::from)?;
7937        }
7938        #[cfg(feature = "pml-extensions")]
7939        if let Some(ref val) = self.ext_lst {
7940            val.write_element("p:extLst", writer)?;
7941        }
7942        #[cfg(feature = "extra-children")]
7943        {
7944            emit_idx += 1;
7945        }
7946        #[cfg(feature = "extra-children")]
7947        for extra in extra_iter {
7948            extra.node.write_to(writer).map_err(SerializeError::from)?;
7949        }
7950        Ok(())
7951    }
7952
7953    fn is_empty_element(&self) -> bool {
7954        false
7955    }
7956}
7957
7958impl ToXml for CTGroupShapeNonVisual {
7959    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
7960        #[cfg(feature = "extra-children")]
7961        let mut extra_iter = self.extra_children.iter().peekable();
7962        #[cfg(feature = "extra-children")]
7963        let mut emit_idx: usize = 0;
7964        #[cfg(feature = "extra-children")]
7965        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7966            extra_iter
7967                .next()
7968                .unwrap()
7969                .node
7970                .write_to(writer)
7971                .map_err(SerializeError::from)?;
7972        }
7973        {
7974            let val = &self.c_nv_pr;
7975            val.write_element("p:cNvPr", writer)?;
7976        }
7977        #[cfg(feature = "extra-children")]
7978        {
7979            emit_idx += 1;
7980        }
7981        #[cfg(feature = "extra-children")]
7982        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
7983            extra_iter
7984                .next()
7985                .unwrap()
7986                .node
7987                .write_to(writer)
7988                .map_err(SerializeError::from)?;
7989        }
7990        {
7991            let val = &self.c_nv_grp_sp_pr;
7992            val.write_element("p:cNvGrpSpPr", writer)?;
7993        }
7994        #[cfg(feature = "extra-children")]
7995        {
7996            emit_idx += 1;
7997        }
7998        #[cfg(feature = "extra-children")]
7999        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8000            extra_iter
8001                .next()
8002                .unwrap()
8003                .node
8004                .write_to(writer)
8005                .map_err(SerializeError::from)?;
8006        }
8007        {
8008            let val = &self.nv_pr;
8009            val.write_element("p:nvPr", writer)?;
8010        }
8011        #[cfg(feature = "extra-children")]
8012        {
8013            emit_idx += 1;
8014        }
8015        #[cfg(feature = "extra-children")]
8016        for extra in extra_iter {
8017            extra.node.write_to(writer).map_err(SerializeError::from)?;
8018        }
8019        Ok(())
8020    }
8021
8022    fn is_empty_element(&self) -> bool {
8023        false
8024    }
8025}
8026
8027impl ToXml for GroupShape {
8028    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
8029        #[cfg(feature = "extra-children")]
8030        let mut extra_iter = self.extra_children.iter().peekable();
8031        #[cfg(feature = "extra-children")]
8032        let mut emit_idx: usize = 0;
8033        #[cfg(feature = "extra-children")]
8034        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8035            extra_iter
8036                .next()
8037                .unwrap()
8038                .node
8039                .write_to(writer)
8040                .map_err(SerializeError::from)?;
8041        }
8042        {
8043            let val = &self.non_visual_group_properties;
8044            val.write_element("p:nvGrpSpPr", writer)?;
8045        }
8046        #[cfg(feature = "extra-children")]
8047        {
8048            emit_idx += 1;
8049        }
8050        #[cfg(feature = "extra-children")]
8051        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8052            extra_iter
8053                .next()
8054                .unwrap()
8055                .node
8056                .write_to(writer)
8057                .map_err(SerializeError::from)?;
8058        }
8059        {
8060            let val = &self.grp_sp_pr;
8061            val.write_element("p:grpSpPr", writer)?;
8062        }
8063        #[cfg(feature = "extra-children")]
8064        {
8065            emit_idx += 1;
8066        }
8067        for item in &self.shape {
8068            #[cfg(feature = "extra-children")]
8069            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8070                extra_iter
8071                    .next()
8072                    .unwrap()
8073                    .node
8074                    .write_to(writer)
8075                    .map_err(SerializeError::from)?;
8076            }
8077            item.write_element("p:sp", writer)?;
8078            #[cfg(feature = "extra-children")]
8079            {
8080                emit_idx += 1;
8081            }
8082        }
8083        for item in &self.group_shape {
8084            #[cfg(feature = "extra-children")]
8085            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8086                extra_iter
8087                    .next()
8088                    .unwrap()
8089                    .node
8090                    .write_to(writer)
8091                    .map_err(SerializeError::from)?;
8092            }
8093            item.write_element("p:grpSp", writer)?;
8094            #[cfg(feature = "extra-children")]
8095            {
8096                emit_idx += 1;
8097            }
8098        }
8099        for item in &self.graphic_frame {
8100            #[cfg(feature = "extra-children")]
8101            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8102                extra_iter
8103                    .next()
8104                    .unwrap()
8105                    .node
8106                    .write_to(writer)
8107                    .map_err(SerializeError::from)?;
8108            }
8109            item.write_element("p:graphicFrame", writer)?;
8110            #[cfg(feature = "extra-children")]
8111            {
8112                emit_idx += 1;
8113            }
8114        }
8115        for item in &self.connector {
8116            #[cfg(feature = "extra-children")]
8117            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8118                extra_iter
8119                    .next()
8120                    .unwrap()
8121                    .node
8122                    .write_to(writer)
8123                    .map_err(SerializeError::from)?;
8124            }
8125            item.write_element("p:cxnSp", writer)?;
8126            #[cfg(feature = "extra-children")]
8127            {
8128                emit_idx += 1;
8129            }
8130        }
8131        for item in &self.picture {
8132            #[cfg(feature = "extra-children")]
8133            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8134                extra_iter
8135                    .next()
8136                    .unwrap()
8137                    .node
8138                    .write_to(writer)
8139                    .map_err(SerializeError::from)?;
8140            }
8141            item.write_element("p:pic", writer)?;
8142            #[cfg(feature = "extra-children")]
8143            {
8144                emit_idx += 1;
8145            }
8146        }
8147        #[cfg(feature = "pml-external")]
8148        for item in &self.content_part {
8149            #[cfg(feature = "extra-children")]
8150            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8151                extra_iter
8152                    .next()
8153                    .unwrap()
8154                    .node
8155                    .write_to(writer)
8156                    .map_err(SerializeError::from)?;
8157            }
8158            item.write_element("p:contentPart", writer)?;
8159            #[cfg(feature = "extra-children")]
8160            {
8161                emit_idx += 1;
8162            }
8163        }
8164        #[cfg(feature = "extra-children")]
8165        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8166            extra_iter
8167                .next()
8168                .unwrap()
8169                .node
8170                .write_to(writer)
8171                .map_err(SerializeError::from)?;
8172        }
8173        #[cfg(feature = "pml-extensions")]
8174        if let Some(ref val) = self.ext_lst {
8175            val.write_element("p:extLst", writer)?;
8176        }
8177        #[cfg(feature = "extra-children")]
8178        {
8179            emit_idx += 1;
8180        }
8181        #[cfg(feature = "extra-children")]
8182        for extra in extra_iter {
8183            extra.node.write_to(writer).map_err(SerializeError::from)?;
8184        }
8185        Ok(())
8186    }
8187
8188    fn is_empty_element(&self) -> bool {
8189        false
8190    }
8191}
8192
8193impl ToXml for CTRel {
8194    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
8195        #[cfg(feature = "extra-children")]
8196        for child in &self.extra_children {
8197            child.node.write_to(writer).map_err(SerializeError::from)?;
8198        }
8199        Ok(())
8200    }
8201
8202    fn is_empty_element(&self) -> bool {
8203        #[cfg(feature = "extra-children")]
8204        if !self.extra_children.is_empty() {
8205            return false;
8206        }
8207        true
8208    }
8209}
8210
8211impl ToXml for EGChildSlide {
8212    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
8213        #[cfg(feature = "extra-children")]
8214        let mut extra_iter = self.extra_children.iter().peekable();
8215        #[cfg(feature = "extra-children")]
8216        let mut emit_idx: usize = 0;
8217        #[cfg(feature = "extra-children")]
8218        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8219            extra_iter
8220                .next()
8221                .unwrap()
8222                .node
8223                .write_to(writer)
8224                .map_err(SerializeError::from)?;
8225        }
8226        if let Some(ref val) = self.clr_map_ovr {
8227            val.write_element("p:clrMapOvr", writer)?;
8228        }
8229        #[cfg(feature = "extra-children")]
8230        {
8231            emit_idx += 1;
8232        }
8233        #[cfg(feature = "extra-children")]
8234        for extra in extra_iter {
8235            extra.node.write_to(writer).map_err(SerializeError::from)?;
8236        }
8237        Ok(())
8238    }
8239
8240    fn is_empty_element(&self) -> bool {
8241        if self.clr_map_ovr.is_some() {
8242            return false;
8243        }
8244        #[cfg(feature = "extra-children")]
8245        if !self.extra_children.is_empty() {
8246            return false;
8247        }
8248        true
8249    }
8250}
8251
8252impl ToXml for PAGChildSlide {
8253    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
8254        #[allow(unused_mut)]
8255        let mut start = start;
8256        if let Some(ref val) = self.show_master_sp {
8257            start.push_attribute(("showMasterSp", if *val { "1" } else { "0" }));
8258        }
8259        if let Some(ref val) = self.show_master_ph_anim {
8260            start.push_attribute(("showMasterPhAnim", if *val { "1" } else { "0" }));
8261        }
8262        #[cfg(feature = "extra-attrs")]
8263        for (key, value) in &self.extra_attrs {
8264            start.push_attribute((key.as_str(), value.as_str()));
8265        }
8266        start
8267    }
8268
8269    fn is_empty_element(&self) -> bool {
8270        true
8271    }
8272}
8273
8274impl ToXml for CTBackgroundProperties {
8275    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
8276        #[allow(unused_mut)]
8277        let mut start = start;
8278        if let Some(ref val) = self.shade_to_title {
8279            start.push_attribute(("shadeToTitle", if *val { "1" } else { "0" }));
8280        }
8281        #[cfg(feature = "extra-attrs")]
8282        for (key, value) in &self.extra_attrs {
8283            start.push_attribute((key.as_str(), value.as_str()));
8284        }
8285        start
8286    }
8287
8288    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
8289        #[cfg(feature = "extra-children")]
8290        let mut extra_iter = self.extra_children.iter().peekable();
8291        #[cfg(feature = "extra-children")]
8292        let mut emit_idx: usize = 0;
8293        #[cfg(feature = "extra-children")]
8294        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8295            extra_iter
8296                .next()
8297                .unwrap()
8298                .node
8299                .write_to(writer)
8300                .map_err(SerializeError::from)?;
8301        }
8302        if let Some(ref val) = self.ext_lst {
8303            val.write_element("p:extLst", writer)?;
8304        }
8305        #[cfg(feature = "extra-children")]
8306        {
8307            emit_idx += 1;
8308        }
8309        #[cfg(feature = "extra-children")]
8310        for extra in extra_iter {
8311            extra.node.write_to(writer).map_err(SerializeError::from)?;
8312        }
8313        Ok(())
8314    }
8315
8316    fn is_empty_element(&self) -> bool {
8317        if self.ext_lst.is_some() {
8318            return false;
8319        }
8320        #[cfg(feature = "extra-children")]
8321        if !self.extra_children.is_empty() {
8322            return false;
8323        }
8324        true
8325    }
8326}
8327
8328impl ToXml for EGBackground {
8329    fn write_element<W: Write>(
8330        &self,
8331        _tag: &str,
8332        writer: &mut Writer<W>,
8333    ) -> Result<(), SerializeError> {
8334        match self {
8335            Self::BgPr(inner) => inner.write_element("p:bgPr", writer)?,
8336            Self::BgRef(inner) => inner.write_element("p:bgRef", writer)?,
8337        }
8338        Ok(())
8339    }
8340}
8341
8342impl ToXml for CTBackground {
8343    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
8344        #[allow(unused_mut)]
8345        let mut start = start;
8346        #[cfg(feature = "pml-styling")]
8347        if let Some(ref val) = self.bw_mode {
8348            {
8349                let s = val.to_string();
8350                start.push_attribute(("bwMode", s.as_str()));
8351            }
8352        }
8353        #[cfg(feature = "extra-attrs")]
8354        for (key, value) in &self.extra_attrs {
8355            start.push_attribute((key.as_str(), value.as_str()));
8356        }
8357        start
8358    }
8359
8360    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
8361        #[cfg(feature = "extra-children")]
8362        let mut extra_iter = self.extra_children.iter().peekable();
8363        #[cfg(feature = "extra-children")]
8364        let mut emit_idx: usize = 0;
8365        #[cfg(feature = "extra-children")]
8366        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8367            extra_iter
8368                .next()
8369                .unwrap()
8370                .node
8371                .write_to(writer)
8372                .map_err(SerializeError::from)?;
8373        }
8374        if let Some(ref val) = self.background {
8375            val.write_element("", writer)?;
8376        }
8377        #[cfg(feature = "extra-children")]
8378        {
8379            emit_idx += 1;
8380        }
8381        #[cfg(feature = "extra-children")]
8382        for extra in extra_iter {
8383            extra.node.write_to(writer).map_err(SerializeError::from)?;
8384        }
8385        Ok(())
8386    }
8387
8388    fn is_empty_element(&self) -> bool {
8389        false
8390    }
8391}
8392
8393impl ToXml for CommonSlideData {
8394    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
8395        #[allow(unused_mut)]
8396        let mut start = start;
8397        if let Some(ref val) = self.name {
8398            start.push_attribute(("name", val.as_str()));
8399        }
8400        #[cfg(feature = "extra-attrs")]
8401        for (key, value) in &self.extra_attrs {
8402            start.push_attribute((key.as_str(), value.as_str()));
8403        }
8404        start
8405    }
8406
8407    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
8408        #[cfg(feature = "extra-children")]
8409        let mut extra_iter = self.extra_children.iter().peekable();
8410        #[cfg(feature = "extra-children")]
8411        let mut emit_idx: usize = 0;
8412        #[cfg(feature = "extra-children")]
8413        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8414            extra_iter
8415                .next()
8416                .unwrap()
8417                .node
8418                .write_to(writer)
8419                .map_err(SerializeError::from)?;
8420        }
8421        #[cfg(feature = "pml-styling")]
8422        if let Some(ref val) = self.bg {
8423            val.write_element("p:bg", writer)?;
8424        }
8425        #[cfg(feature = "extra-children")]
8426        {
8427            emit_idx += 1;
8428        }
8429        #[cfg(feature = "extra-children")]
8430        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8431            extra_iter
8432                .next()
8433                .unwrap()
8434                .node
8435                .write_to(writer)
8436                .map_err(SerializeError::from)?;
8437        }
8438        {
8439            let val = &self.shape_tree;
8440            val.write_element("p:spTree", writer)?;
8441        }
8442        #[cfg(feature = "extra-children")]
8443        {
8444            emit_idx += 1;
8445        }
8446        #[cfg(feature = "extra-children")]
8447        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8448            extra_iter
8449                .next()
8450                .unwrap()
8451                .node
8452                .write_to(writer)
8453                .map_err(SerializeError::from)?;
8454        }
8455        #[cfg(feature = "pml-external")]
8456        if let Some(ref val) = self.cust_data_lst {
8457            val.write_element("p:custDataLst", writer)?;
8458        }
8459        #[cfg(feature = "extra-children")]
8460        {
8461            emit_idx += 1;
8462        }
8463        #[cfg(feature = "extra-children")]
8464        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8465            extra_iter
8466                .next()
8467                .unwrap()
8468                .node
8469                .write_to(writer)
8470                .map_err(SerializeError::from)?;
8471        }
8472        #[cfg(feature = "pml-external")]
8473        if let Some(ref val) = self.controls {
8474            val.write_element("p:controls", writer)?;
8475        }
8476        #[cfg(feature = "extra-children")]
8477        {
8478            emit_idx += 1;
8479        }
8480        #[cfg(feature = "extra-children")]
8481        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8482            extra_iter
8483                .next()
8484                .unwrap()
8485                .node
8486                .write_to(writer)
8487                .map_err(SerializeError::from)?;
8488        }
8489        #[cfg(feature = "pml-extensions")]
8490        if let Some(ref val) = self.ext_lst {
8491            val.write_element("p:extLst", writer)?;
8492        }
8493        #[cfg(feature = "extra-children")]
8494        {
8495            emit_idx += 1;
8496        }
8497        #[cfg(feature = "extra-children")]
8498        for extra in extra_iter {
8499            extra.node.write_to(writer).map_err(SerializeError::from)?;
8500        }
8501        Ok(())
8502    }
8503
8504    fn is_empty_element(&self) -> bool {
8505        #[cfg(feature = "pml-styling")]
8506        if self.bg.is_some() {
8507            return false;
8508        }
8509        false
8510    }
8511}
8512
8513impl ToXml for Slide {
8514    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
8515        #[allow(unused_mut)]
8516        let mut start = start;
8517        #[cfg(feature = "pml-masters")]
8518        if let Some(ref val) = self.show_master_sp {
8519            start.push_attribute(("showMasterSp", if *val { "1" } else { "0" }));
8520        }
8521        #[cfg(feature = "pml-masters")]
8522        if let Some(ref val) = self.show_master_ph_anim {
8523            start.push_attribute(("showMasterPhAnim", if *val { "1" } else { "0" }));
8524        }
8525        if let Some(ref val) = self.show {
8526            start.push_attribute(("show", if *val { "1" } else { "0" }));
8527        }
8528        #[cfg(feature = "extra-attrs")]
8529        for (key, value) in &self.extra_attrs {
8530            start.push_attribute((key.as_str(), value.as_str()));
8531        }
8532        start
8533    }
8534
8535    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
8536        #[cfg(feature = "extra-children")]
8537        let mut extra_iter = self.extra_children.iter().peekable();
8538        #[cfg(feature = "extra-children")]
8539        let mut emit_idx: usize = 0;
8540        #[cfg(feature = "extra-children")]
8541        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8542            extra_iter
8543                .next()
8544                .unwrap()
8545                .node
8546                .write_to(writer)
8547                .map_err(SerializeError::from)?;
8548        }
8549        {
8550            let val = &self.common_slide_data;
8551            val.write_element("p:cSld", writer)?;
8552        }
8553        #[cfg(feature = "extra-children")]
8554        {
8555            emit_idx += 1;
8556        }
8557        #[cfg(feature = "extra-children")]
8558        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8559            extra_iter
8560                .next()
8561                .unwrap()
8562                .node
8563                .write_to(writer)
8564                .map_err(SerializeError::from)?;
8565        }
8566        #[cfg(feature = "pml-styling")]
8567        if let Some(ref val) = self.clr_map_ovr {
8568            val.write_element("p:clrMapOvr", writer)?;
8569        }
8570        #[cfg(feature = "extra-children")]
8571        {
8572            emit_idx += 1;
8573        }
8574        #[cfg(feature = "extra-children")]
8575        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8576            extra_iter
8577                .next()
8578                .unwrap()
8579                .node
8580                .write_to(writer)
8581                .map_err(SerializeError::from)?;
8582        }
8583        #[cfg(feature = "pml-transitions")]
8584        if let Some(ref val) = self.transition {
8585            val.write_element("p:transition", writer)?;
8586        }
8587        #[cfg(feature = "extra-children")]
8588        {
8589            emit_idx += 1;
8590        }
8591        #[cfg(feature = "extra-children")]
8592        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8593            extra_iter
8594                .next()
8595                .unwrap()
8596                .node
8597                .write_to(writer)
8598                .map_err(SerializeError::from)?;
8599        }
8600        #[cfg(feature = "pml-animations")]
8601        if let Some(ref val) = self.timing {
8602            val.write_element("p:timing", writer)?;
8603        }
8604        #[cfg(feature = "extra-children")]
8605        {
8606            emit_idx += 1;
8607        }
8608        #[cfg(feature = "extra-children")]
8609        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8610            extra_iter
8611                .next()
8612                .unwrap()
8613                .node
8614                .write_to(writer)
8615                .map_err(SerializeError::from)?;
8616        }
8617        #[cfg(feature = "pml-extensions")]
8618        if let Some(ref val) = self.ext_lst {
8619            val.write_element("p:extLst", writer)?;
8620        }
8621        #[cfg(feature = "extra-children")]
8622        {
8623            emit_idx += 1;
8624        }
8625        #[cfg(feature = "extra-children")]
8626        for extra in extra_iter {
8627            extra.node.write_to(writer).map_err(SerializeError::from)?;
8628        }
8629        Ok(())
8630    }
8631
8632    fn is_empty_element(&self) -> bool {
8633        false
8634    }
8635}
8636
8637impl ToXml for SlideLayout {
8638    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
8639        #[allow(unused_mut)]
8640        let mut start = start;
8641        #[cfg(feature = "pml-masters")]
8642        if let Some(ref val) = self.show_master_sp {
8643            start.push_attribute(("showMasterSp", if *val { "1" } else { "0" }));
8644        }
8645        #[cfg(feature = "pml-masters")]
8646        if let Some(ref val) = self.show_master_ph_anim {
8647            start.push_attribute(("showMasterPhAnim", if *val { "1" } else { "0" }));
8648        }
8649        #[cfg(feature = "pml-masters")]
8650        if let Some(ref val) = self.matching_name {
8651            start.push_attribute(("matchingName", val.as_str()));
8652        }
8653        #[cfg(feature = "pml-masters")]
8654        if let Some(ref val) = self.r#type {
8655            {
8656                let s = val.to_string();
8657                start.push_attribute(("type", s.as_str()));
8658            }
8659        }
8660        #[cfg(feature = "pml-masters")]
8661        if let Some(ref val) = self.preserve {
8662            start.push_attribute(("preserve", if *val { "1" } else { "0" }));
8663        }
8664        #[cfg(feature = "pml-masters")]
8665        if let Some(ref val) = self.user_drawn {
8666            start.push_attribute(("userDrawn", if *val { "1" } else { "0" }));
8667        }
8668        #[cfg(feature = "extra-attrs")]
8669        for (key, value) in &self.extra_attrs {
8670            start.push_attribute((key.as_str(), value.as_str()));
8671        }
8672        start
8673    }
8674
8675    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
8676        #[cfg(feature = "extra-children")]
8677        let mut extra_iter = self.extra_children.iter().peekable();
8678        #[cfg(feature = "extra-children")]
8679        let mut emit_idx: usize = 0;
8680        #[cfg(feature = "extra-children")]
8681        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8682            extra_iter
8683                .next()
8684                .unwrap()
8685                .node
8686                .write_to(writer)
8687                .map_err(SerializeError::from)?;
8688        }
8689        {
8690            let val = &self.common_slide_data;
8691            val.write_element("p:cSld", writer)?;
8692        }
8693        #[cfg(feature = "extra-children")]
8694        {
8695            emit_idx += 1;
8696        }
8697        #[cfg(feature = "extra-children")]
8698        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8699            extra_iter
8700                .next()
8701                .unwrap()
8702                .node
8703                .write_to(writer)
8704                .map_err(SerializeError::from)?;
8705        }
8706        #[cfg(feature = "pml-styling")]
8707        if let Some(ref val) = self.clr_map_ovr {
8708            val.write_element("p:clrMapOvr", writer)?;
8709        }
8710        #[cfg(feature = "extra-children")]
8711        {
8712            emit_idx += 1;
8713        }
8714        #[cfg(feature = "extra-children")]
8715        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8716            extra_iter
8717                .next()
8718                .unwrap()
8719                .node
8720                .write_to(writer)
8721                .map_err(SerializeError::from)?;
8722        }
8723        #[cfg(feature = "pml-transitions")]
8724        if let Some(ref val) = self.transition {
8725            val.write_element("p:transition", writer)?;
8726        }
8727        #[cfg(feature = "extra-children")]
8728        {
8729            emit_idx += 1;
8730        }
8731        #[cfg(feature = "extra-children")]
8732        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8733            extra_iter
8734                .next()
8735                .unwrap()
8736                .node
8737                .write_to(writer)
8738                .map_err(SerializeError::from)?;
8739        }
8740        #[cfg(feature = "pml-animations")]
8741        if let Some(ref val) = self.timing {
8742            val.write_element("p:timing", writer)?;
8743        }
8744        #[cfg(feature = "extra-children")]
8745        {
8746            emit_idx += 1;
8747        }
8748        #[cfg(feature = "extra-children")]
8749        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8750            extra_iter
8751                .next()
8752                .unwrap()
8753                .node
8754                .write_to(writer)
8755                .map_err(SerializeError::from)?;
8756        }
8757        #[cfg(feature = "pml-masters")]
8758        if let Some(ref val) = self.hf {
8759            val.write_element("p:hf", writer)?;
8760        }
8761        #[cfg(feature = "extra-children")]
8762        {
8763            emit_idx += 1;
8764        }
8765        #[cfg(feature = "extra-children")]
8766        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8767            extra_iter
8768                .next()
8769                .unwrap()
8770                .node
8771                .write_to(writer)
8772                .map_err(SerializeError::from)?;
8773        }
8774        #[cfg(feature = "pml-extensions")]
8775        if let Some(ref val) = self.ext_lst {
8776            val.write_element("p:extLst", writer)?;
8777        }
8778        #[cfg(feature = "extra-children")]
8779        {
8780            emit_idx += 1;
8781        }
8782        #[cfg(feature = "extra-children")]
8783        for extra in extra_iter {
8784            extra.node.write_to(writer).map_err(SerializeError::from)?;
8785        }
8786        Ok(())
8787    }
8788
8789    fn is_empty_element(&self) -> bool {
8790        false
8791    }
8792}
8793
8794impl ToXml for CTSlideMasterTextStyles {
8795    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
8796        #[cfg(feature = "extra-children")]
8797        let mut extra_iter = self.extra_children.iter().peekable();
8798        #[cfg(feature = "extra-children")]
8799        let mut emit_idx: usize = 0;
8800        #[cfg(feature = "extra-children")]
8801        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8802            extra_iter
8803                .next()
8804                .unwrap()
8805                .node
8806                .write_to(writer)
8807                .map_err(SerializeError::from)?;
8808        }
8809        if let Some(ref val) = self.title_style {
8810            val.write_element("p:titleStyle", writer)?;
8811        }
8812        #[cfg(feature = "extra-children")]
8813        {
8814            emit_idx += 1;
8815        }
8816        #[cfg(feature = "extra-children")]
8817        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8818            extra_iter
8819                .next()
8820                .unwrap()
8821                .node
8822                .write_to(writer)
8823                .map_err(SerializeError::from)?;
8824        }
8825        if let Some(ref val) = self.body_style {
8826            val.write_element("p:bodyStyle", writer)?;
8827        }
8828        #[cfg(feature = "extra-children")]
8829        {
8830            emit_idx += 1;
8831        }
8832        #[cfg(feature = "extra-children")]
8833        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8834            extra_iter
8835                .next()
8836                .unwrap()
8837                .node
8838                .write_to(writer)
8839                .map_err(SerializeError::from)?;
8840        }
8841        if let Some(ref val) = self.other_style {
8842            val.write_element("p:otherStyle", writer)?;
8843        }
8844        #[cfg(feature = "extra-children")]
8845        {
8846            emit_idx += 1;
8847        }
8848        #[cfg(feature = "extra-children")]
8849        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8850            extra_iter
8851                .next()
8852                .unwrap()
8853                .node
8854                .write_to(writer)
8855                .map_err(SerializeError::from)?;
8856        }
8857        if let Some(ref val) = self.ext_lst {
8858            val.write_element("p:extLst", writer)?;
8859        }
8860        #[cfg(feature = "extra-children")]
8861        {
8862            emit_idx += 1;
8863        }
8864        #[cfg(feature = "extra-children")]
8865        for extra in extra_iter {
8866            extra.node.write_to(writer).map_err(SerializeError::from)?;
8867        }
8868        Ok(())
8869    }
8870
8871    fn is_empty_element(&self) -> bool {
8872        if self.title_style.is_some() {
8873            return false;
8874        }
8875        if self.body_style.is_some() {
8876            return false;
8877        }
8878        if self.other_style.is_some() {
8879            return false;
8880        }
8881        if self.ext_lst.is_some() {
8882            return false;
8883        }
8884        #[cfg(feature = "extra-children")]
8885        if !self.extra_children.is_empty() {
8886            return false;
8887        }
8888        true
8889    }
8890}
8891
8892impl ToXml for CTSlideLayoutIdListEntry {
8893    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
8894        #[allow(unused_mut)]
8895        let mut start = start;
8896        if let Some(ref val) = self.id {
8897            {
8898                let s = val.to_string();
8899                start.push_attribute(("id", s.as_str()));
8900            }
8901        }
8902        #[cfg(feature = "extra-attrs")]
8903        for (key, value) in &self.extra_attrs {
8904            start.push_attribute((key.as_str(), value.as_str()));
8905        }
8906        start
8907    }
8908
8909    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
8910        #[cfg(feature = "extra-children")]
8911        let mut extra_iter = self.extra_children.iter().peekable();
8912        #[cfg(feature = "extra-children")]
8913        let mut emit_idx: usize = 0;
8914        #[cfg(feature = "extra-children")]
8915        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8916            extra_iter
8917                .next()
8918                .unwrap()
8919                .node
8920                .write_to(writer)
8921                .map_err(SerializeError::from)?;
8922        }
8923        if let Some(ref val) = self.ext_lst {
8924            val.write_element("p:extLst", writer)?;
8925        }
8926        #[cfg(feature = "extra-children")]
8927        {
8928            emit_idx += 1;
8929        }
8930        #[cfg(feature = "extra-children")]
8931        for extra in extra_iter {
8932            extra.node.write_to(writer).map_err(SerializeError::from)?;
8933        }
8934        Ok(())
8935    }
8936
8937    fn is_empty_element(&self) -> bool {
8938        if self.ext_lst.is_some() {
8939            return false;
8940        }
8941        #[cfg(feature = "extra-children")]
8942        if !self.extra_children.is_empty() {
8943            return false;
8944        }
8945        true
8946    }
8947}
8948
8949impl ToXml for CTSlideLayoutIdList {
8950    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
8951        #[cfg(feature = "extra-children")]
8952        let mut extra_iter = self.extra_children.iter().peekable();
8953        #[cfg(feature = "extra-children")]
8954        let mut emit_idx: usize = 0;
8955        for item in &self.sld_layout_id {
8956            #[cfg(feature = "extra-children")]
8957            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
8958                extra_iter
8959                    .next()
8960                    .unwrap()
8961                    .node
8962                    .write_to(writer)
8963                    .map_err(SerializeError::from)?;
8964            }
8965            item.write_element("p:sldLayoutId", writer)?;
8966            #[cfg(feature = "extra-children")]
8967            {
8968                emit_idx += 1;
8969            }
8970        }
8971        #[cfg(feature = "extra-children")]
8972        for extra in extra_iter {
8973            extra.node.write_to(writer).map_err(SerializeError::from)?;
8974        }
8975        Ok(())
8976    }
8977
8978    fn is_empty_element(&self) -> bool {
8979        if !self.sld_layout_id.is_empty() {
8980            return false;
8981        }
8982        #[cfg(feature = "extra-children")]
8983        if !self.extra_children.is_empty() {
8984            return false;
8985        }
8986        true
8987    }
8988}
8989
8990impl ToXml for SlideMaster {
8991    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
8992        #[allow(unused_mut)]
8993        let mut start = start;
8994        #[cfg(feature = "pml-masters")]
8995        if let Some(ref val) = self.preserve {
8996            start.push_attribute(("preserve", if *val { "1" } else { "0" }));
8997        }
8998        #[cfg(feature = "extra-attrs")]
8999        for (key, value) in &self.extra_attrs {
9000            start.push_attribute((key.as_str(), value.as_str()));
9001        }
9002        start
9003    }
9004
9005    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
9006        #[cfg(feature = "extra-children")]
9007        let mut extra_iter = self.extra_children.iter().peekable();
9008        #[cfg(feature = "extra-children")]
9009        let mut emit_idx: usize = 0;
9010        #[cfg(feature = "extra-children")]
9011        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9012            extra_iter
9013                .next()
9014                .unwrap()
9015                .node
9016                .write_to(writer)
9017                .map_err(SerializeError::from)?;
9018        }
9019        {
9020            let val = &self.common_slide_data;
9021            val.write_element("p:cSld", writer)?;
9022        }
9023        #[cfg(feature = "extra-children")]
9024        {
9025            emit_idx += 1;
9026        }
9027        #[cfg(feature = "extra-children")]
9028        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9029            extra_iter
9030                .next()
9031                .unwrap()
9032                .node
9033                .write_to(writer)
9034                .map_err(SerializeError::from)?;
9035        }
9036        {
9037            let val = &self.clr_map;
9038            val.write_element("p:clrMap", writer)?;
9039        }
9040        #[cfg(feature = "extra-children")]
9041        {
9042            emit_idx += 1;
9043        }
9044        #[cfg(feature = "extra-children")]
9045        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9046            extra_iter
9047                .next()
9048                .unwrap()
9049                .node
9050                .write_to(writer)
9051                .map_err(SerializeError::from)?;
9052        }
9053        #[cfg(feature = "pml-masters")]
9054        if let Some(ref val) = self.sld_layout_id_lst {
9055            val.write_element("p:sldLayoutIdLst", writer)?;
9056        }
9057        #[cfg(feature = "extra-children")]
9058        {
9059            emit_idx += 1;
9060        }
9061        #[cfg(feature = "extra-children")]
9062        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9063            extra_iter
9064                .next()
9065                .unwrap()
9066                .node
9067                .write_to(writer)
9068                .map_err(SerializeError::from)?;
9069        }
9070        #[cfg(feature = "pml-transitions")]
9071        if let Some(ref val) = self.transition {
9072            val.write_element("p:transition", writer)?;
9073        }
9074        #[cfg(feature = "extra-children")]
9075        {
9076            emit_idx += 1;
9077        }
9078        #[cfg(feature = "extra-children")]
9079        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9080            extra_iter
9081                .next()
9082                .unwrap()
9083                .node
9084                .write_to(writer)
9085                .map_err(SerializeError::from)?;
9086        }
9087        #[cfg(feature = "pml-animations")]
9088        if let Some(ref val) = self.timing {
9089            val.write_element("p:timing", writer)?;
9090        }
9091        #[cfg(feature = "extra-children")]
9092        {
9093            emit_idx += 1;
9094        }
9095        #[cfg(feature = "extra-children")]
9096        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9097            extra_iter
9098                .next()
9099                .unwrap()
9100                .node
9101                .write_to(writer)
9102                .map_err(SerializeError::from)?;
9103        }
9104        #[cfg(feature = "pml-masters")]
9105        if let Some(ref val) = self.hf {
9106            val.write_element("p:hf", writer)?;
9107        }
9108        #[cfg(feature = "extra-children")]
9109        {
9110            emit_idx += 1;
9111        }
9112        #[cfg(feature = "extra-children")]
9113        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9114            extra_iter
9115                .next()
9116                .unwrap()
9117                .node
9118                .write_to(writer)
9119                .map_err(SerializeError::from)?;
9120        }
9121        #[cfg(feature = "pml-styling")]
9122        if let Some(ref val) = self.tx_styles {
9123            val.write_element("p:txStyles", writer)?;
9124        }
9125        #[cfg(feature = "extra-children")]
9126        {
9127            emit_idx += 1;
9128        }
9129        #[cfg(feature = "extra-children")]
9130        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9131            extra_iter
9132                .next()
9133                .unwrap()
9134                .node
9135                .write_to(writer)
9136                .map_err(SerializeError::from)?;
9137        }
9138        #[cfg(feature = "pml-extensions")]
9139        if let Some(ref val) = self.ext_lst {
9140            val.write_element("p:extLst", writer)?;
9141        }
9142        #[cfg(feature = "extra-children")]
9143        {
9144            emit_idx += 1;
9145        }
9146        #[cfg(feature = "extra-children")]
9147        for extra in extra_iter {
9148            extra.node.write_to(writer).map_err(SerializeError::from)?;
9149        }
9150        Ok(())
9151    }
9152
9153    fn is_empty_element(&self) -> bool {
9154        false
9155    }
9156}
9157
9158impl ToXml for HandoutMaster {
9159    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
9160        #[cfg(feature = "extra-children")]
9161        let mut extra_iter = self.extra_children.iter().peekable();
9162        #[cfg(feature = "extra-children")]
9163        let mut emit_idx: usize = 0;
9164        #[cfg(feature = "extra-children")]
9165        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9166            extra_iter
9167                .next()
9168                .unwrap()
9169                .node
9170                .write_to(writer)
9171                .map_err(SerializeError::from)?;
9172        }
9173        {
9174            let val = &self.common_slide_data;
9175            val.write_element("p:cSld", writer)?;
9176        }
9177        #[cfg(feature = "extra-children")]
9178        {
9179            emit_idx += 1;
9180        }
9181        #[cfg(feature = "extra-children")]
9182        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9183            extra_iter
9184                .next()
9185                .unwrap()
9186                .node
9187                .write_to(writer)
9188                .map_err(SerializeError::from)?;
9189        }
9190        {
9191            let val = &self.clr_map;
9192            val.write_element("p:clrMap", writer)?;
9193        }
9194        #[cfg(feature = "extra-children")]
9195        {
9196            emit_idx += 1;
9197        }
9198        #[cfg(feature = "extra-children")]
9199        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9200            extra_iter
9201                .next()
9202                .unwrap()
9203                .node
9204                .write_to(writer)
9205                .map_err(SerializeError::from)?;
9206        }
9207        #[cfg(feature = "pml-masters")]
9208        if let Some(ref val) = self.hf {
9209            val.write_element("p:hf", writer)?;
9210        }
9211        #[cfg(feature = "extra-children")]
9212        {
9213            emit_idx += 1;
9214        }
9215        #[cfg(feature = "extra-children")]
9216        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9217            extra_iter
9218                .next()
9219                .unwrap()
9220                .node
9221                .write_to(writer)
9222                .map_err(SerializeError::from)?;
9223        }
9224        #[cfg(feature = "pml-extensions")]
9225        if let Some(ref val) = self.ext_lst {
9226            val.write_element("p:extLst", writer)?;
9227        }
9228        #[cfg(feature = "extra-children")]
9229        {
9230            emit_idx += 1;
9231        }
9232        #[cfg(feature = "extra-children")]
9233        for extra in extra_iter {
9234            extra.node.write_to(writer).map_err(SerializeError::from)?;
9235        }
9236        Ok(())
9237    }
9238
9239    fn is_empty_element(&self) -> bool {
9240        false
9241    }
9242}
9243
9244impl ToXml for NotesMaster {
9245    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
9246        #[cfg(feature = "extra-children")]
9247        let mut extra_iter = self.extra_children.iter().peekable();
9248        #[cfg(feature = "extra-children")]
9249        let mut emit_idx: usize = 0;
9250        #[cfg(feature = "extra-children")]
9251        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9252            extra_iter
9253                .next()
9254                .unwrap()
9255                .node
9256                .write_to(writer)
9257                .map_err(SerializeError::from)?;
9258        }
9259        {
9260            let val = &self.common_slide_data;
9261            val.write_element("p:cSld", writer)?;
9262        }
9263        #[cfg(feature = "extra-children")]
9264        {
9265            emit_idx += 1;
9266        }
9267        #[cfg(feature = "extra-children")]
9268        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9269            extra_iter
9270                .next()
9271                .unwrap()
9272                .node
9273                .write_to(writer)
9274                .map_err(SerializeError::from)?;
9275        }
9276        {
9277            let val = &self.clr_map;
9278            val.write_element("p:clrMap", writer)?;
9279        }
9280        #[cfg(feature = "extra-children")]
9281        {
9282            emit_idx += 1;
9283        }
9284        #[cfg(feature = "extra-children")]
9285        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9286            extra_iter
9287                .next()
9288                .unwrap()
9289                .node
9290                .write_to(writer)
9291                .map_err(SerializeError::from)?;
9292        }
9293        #[cfg(feature = "pml-notes")]
9294        if let Some(ref val) = self.hf {
9295            val.write_element("p:hf", writer)?;
9296        }
9297        #[cfg(feature = "extra-children")]
9298        {
9299            emit_idx += 1;
9300        }
9301        #[cfg(feature = "extra-children")]
9302        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9303            extra_iter
9304                .next()
9305                .unwrap()
9306                .node
9307                .write_to(writer)
9308                .map_err(SerializeError::from)?;
9309        }
9310        #[cfg(feature = "pml-styling")]
9311        if let Some(ref val) = self.notes_style {
9312            val.write_element("p:notesStyle", writer)?;
9313        }
9314        #[cfg(feature = "extra-children")]
9315        {
9316            emit_idx += 1;
9317        }
9318        #[cfg(feature = "extra-children")]
9319        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9320            extra_iter
9321                .next()
9322                .unwrap()
9323                .node
9324                .write_to(writer)
9325                .map_err(SerializeError::from)?;
9326        }
9327        #[cfg(feature = "pml-extensions")]
9328        if let Some(ref val) = self.ext_lst {
9329            val.write_element("p:extLst", writer)?;
9330        }
9331        #[cfg(feature = "extra-children")]
9332        {
9333            emit_idx += 1;
9334        }
9335        #[cfg(feature = "extra-children")]
9336        for extra in extra_iter {
9337            extra.node.write_to(writer).map_err(SerializeError::from)?;
9338        }
9339        Ok(())
9340    }
9341
9342    fn is_empty_element(&self) -> bool {
9343        false
9344    }
9345}
9346
9347impl ToXml for NotesSlide {
9348    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
9349        #[allow(unused_mut)]
9350        let mut start = start;
9351        #[cfg(feature = "pml-notes")]
9352        if let Some(ref val) = self.show_master_sp {
9353            start.push_attribute(("showMasterSp", if *val { "1" } else { "0" }));
9354        }
9355        #[cfg(feature = "pml-notes")]
9356        if let Some(ref val) = self.show_master_ph_anim {
9357            start.push_attribute(("showMasterPhAnim", if *val { "1" } else { "0" }));
9358        }
9359        #[cfg(feature = "extra-attrs")]
9360        for (key, value) in &self.extra_attrs {
9361            start.push_attribute((key.as_str(), value.as_str()));
9362        }
9363        start
9364    }
9365
9366    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
9367        #[cfg(feature = "extra-children")]
9368        let mut extra_iter = self.extra_children.iter().peekable();
9369        #[cfg(feature = "extra-children")]
9370        let mut emit_idx: usize = 0;
9371        #[cfg(feature = "extra-children")]
9372        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9373            extra_iter
9374                .next()
9375                .unwrap()
9376                .node
9377                .write_to(writer)
9378                .map_err(SerializeError::from)?;
9379        }
9380        {
9381            let val = &self.common_slide_data;
9382            val.write_element("p:cSld", writer)?;
9383        }
9384        #[cfg(feature = "extra-children")]
9385        {
9386            emit_idx += 1;
9387        }
9388        #[cfg(feature = "extra-children")]
9389        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9390            extra_iter
9391                .next()
9392                .unwrap()
9393                .node
9394                .write_to(writer)
9395                .map_err(SerializeError::from)?;
9396        }
9397        #[cfg(feature = "pml-styling")]
9398        if let Some(ref val) = self.clr_map_ovr {
9399            val.write_element("p:clrMapOvr", writer)?;
9400        }
9401        #[cfg(feature = "extra-children")]
9402        {
9403            emit_idx += 1;
9404        }
9405        #[cfg(feature = "extra-children")]
9406        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9407            extra_iter
9408                .next()
9409                .unwrap()
9410                .node
9411                .write_to(writer)
9412                .map_err(SerializeError::from)?;
9413        }
9414        #[cfg(feature = "pml-extensions")]
9415        if let Some(ref val) = self.ext_lst {
9416            val.write_element("p:extLst", writer)?;
9417        }
9418        #[cfg(feature = "extra-children")]
9419        {
9420            emit_idx += 1;
9421        }
9422        #[cfg(feature = "extra-children")]
9423        for extra in extra_iter {
9424            extra.node.write_to(writer).map_err(SerializeError::from)?;
9425        }
9426        Ok(())
9427    }
9428
9429    fn is_empty_element(&self) -> bool {
9430        false
9431    }
9432}
9433
9434impl ToXml for CTSlideSyncProperties {
9435    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
9436        #[allow(unused_mut)]
9437        let mut start = start;
9438        {
9439            let val = &self.server_sld_id;
9440            start.push_attribute(("serverSldId", val.as_str()));
9441        }
9442        {
9443            let val = &self.server_sld_modified_time;
9444            start.push_attribute(("serverSldModifiedTime", val.as_str()));
9445        }
9446        {
9447            let val = &self.client_inserted_time;
9448            start.push_attribute(("clientInsertedTime", val.as_str()));
9449        }
9450        #[cfg(feature = "extra-attrs")]
9451        for (key, value) in &self.extra_attrs {
9452            start.push_attribute((key.as_str(), value.as_str()));
9453        }
9454        start
9455    }
9456
9457    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
9458        #[cfg(feature = "extra-children")]
9459        let mut extra_iter = self.extra_children.iter().peekable();
9460        #[cfg(feature = "extra-children")]
9461        let mut emit_idx: usize = 0;
9462        #[cfg(feature = "extra-children")]
9463        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9464            extra_iter
9465                .next()
9466                .unwrap()
9467                .node
9468                .write_to(writer)
9469                .map_err(SerializeError::from)?;
9470        }
9471        if let Some(ref val) = self.ext_lst {
9472            val.write_element("p:extLst", writer)?;
9473        }
9474        #[cfg(feature = "extra-children")]
9475        {
9476            emit_idx += 1;
9477        }
9478        #[cfg(feature = "extra-children")]
9479        for extra in extra_iter {
9480            extra.node.write_to(writer).map_err(SerializeError::from)?;
9481        }
9482        Ok(())
9483    }
9484
9485    fn is_empty_element(&self) -> bool {
9486        if self.ext_lst.is_some() {
9487            return false;
9488        }
9489        #[cfg(feature = "extra-children")]
9490        if !self.extra_children.is_empty() {
9491            return false;
9492        }
9493        true
9494    }
9495}
9496
9497impl ToXml for CTStringTag {
9498    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
9499        #[allow(unused_mut)]
9500        let mut start = start;
9501        {
9502            let val = &self.name;
9503            start.push_attribute(("name", val.as_str()));
9504        }
9505        {
9506            let val = &self.value;
9507            start.push_attribute(("val", val.as_str()));
9508        }
9509        #[cfg(feature = "extra-attrs")]
9510        for (key, value) in &self.extra_attrs {
9511            start.push_attribute((key.as_str(), value.as_str()));
9512        }
9513        start
9514    }
9515
9516    fn is_empty_element(&self) -> bool {
9517        true
9518    }
9519}
9520
9521impl ToXml for CTTagList {
9522    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
9523        #[cfg(feature = "extra-children")]
9524        let mut extra_iter = self.extra_children.iter().peekable();
9525        #[cfg(feature = "extra-children")]
9526        let mut emit_idx: usize = 0;
9527        for item in &self.tag {
9528            #[cfg(feature = "extra-children")]
9529            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9530                extra_iter
9531                    .next()
9532                    .unwrap()
9533                    .node
9534                    .write_to(writer)
9535                    .map_err(SerializeError::from)?;
9536            }
9537            item.write_element("p:tag", writer)?;
9538            #[cfg(feature = "extra-children")]
9539            {
9540                emit_idx += 1;
9541            }
9542        }
9543        #[cfg(feature = "extra-children")]
9544        for extra in extra_iter {
9545            extra.node.write_to(writer).map_err(SerializeError::from)?;
9546        }
9547        Ok(())
9548    }
9549
9550    fn is_empty_element(&self) -> bool {
9551        if !self.tag.is_empty() {
9552            return false;
9553        }
9554        #[cfg(feature = "extra-children")]
9555        if !self.extra_children.is_empty() {
9556            return false;
9557        }
9558        true
9559    }
9560}
9561
9562impl ToXml for CTNormalViewPortion {
9563    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
9564        #[allow(unused_mut)]
9565        let mut start = start;
9566        {
9567            let val = &self.sz;
9568            {
9569                let s = val.to_string();
9570                start.push_attribute(("sz", s.as_str()));
9571            }
9572        }
9573        if let Some(ref val) = self.auto_adjust {
9574            start.push_attribute(("autoAdjust", if *val { "1" } else { "0" }));
9575        }
9576        #[cfg(feature = "extra-attrs")]
9577        for (key, value) in &self.extra_attrs {
9578            start.push_attribute((key.as_str(), value.as_str()));
9579        }
9580        start
9581    }
9582
9583    fn is_empty_element(&self) -> bool {
9584        true
9585    }
9586}
9587
9588impl ToXml for CTNormalViewProperties {
9589    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
9590        #[allow(unused_mut)]
9591        let mut start = start;
9592        if let Some(ref val) = self.show_outline_icons {
9593            start.push_attribute(("showOutlineIcons", if *val { "1" } else { "0" }));
9594        }
9595        if let Some(ref val) = self.snap_vert_splitter {
9596            start.push_attribute(("snapVertSplitter", if *val { "1" } else { "0" }));
9597        }
9598        if let Some(ref val) = self.vert_bar_state {
9599            {
9600                let s = val.to_string();
9601                start.push_attribute(("vertBarState", s.as_str()));
9602            }
9603        }
9604        if let Some(ref val) = self.horz_bar_state {
9605            {
9606                let s = val.to_string();
9607                start.push_attribute(("horzBarState", s.as_str()));
9608            }
9609        }
9610        if let Some(ref val) = self.prefer_single_view {
9611            start.push_attribute(("preferSingleView", if *val { "1" } else { "0" }));
9612        }
9613        #[cfg(feature = "extra-attrs")]
9614        for (key, value) in &self.extra_attrs {
9615            start.push_attribute((key.as_str(), value.as_str()));
9616        }
9617        start
9618    }
9619
9620    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
9621        #[cfg(feature = "extra-children")]
9622        let mut extra_iter = self.extra_children.iter().peekable();
9623        #[cfg(feature = "extra-children")]
9624        let mut emit_idx: usize = 0;
9625        #[cfg(feature = "extra-children")]
9626        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9627            extra_iter
9628                .next()
9629                .unwrap()
9630                .node
9631                .write_to(writer)
9632                .map_err(SerializeError::from)?;
9633        }
9634        {
9635            let val = &self.restored_left;
9636            val.write_element("p:restoredLeft", writer)?;
9637        }
9638        #[cfg(feature = "extra-children")]
9639        {
9640            emit_idx += 1;
9641        }
9642        #[cfg(feature = "extra-children")]
9643        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9644            extra_iter
9645                .next()
9646                .unwrap()
9647                .node
9648                .write_to(writer)
9649                .map_err(SerializeError::from)?;
9650        }
9651        {
9652            let val = &self.restored_top;
9653            val.write_element("p:restoredTop", writer)?;
9654        }
9655        #[cfg(feature = "extra-children")]
9656        {
9657            emit_idx += 1;
9658        }
9659        #[cfg(feature = "extra-children")]
9660        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9661            extra_iter
9662                .next()
9663                .unwrap()
9664                .node
9665                .write_to(writer)
9666                .map_err(SerializeError::from)?;
9667        }
9668        if let Some(ref val) = self.ext_lst {
9669            val.write_element("p:extLst", writer)?;
9670        }
9671        #[cfg(feature = "extra-children")]
9672        {
9673            emit_idx += 1;
9674        }
9675        #[cfg(feature = "extra-children")]
9676        for extra in extra_iter {
9677            extra.node.write_to(writer).map_err(SerializeError::from)?;
9678        }
9679        Ok(())
9680    }
9681
9682    fn is_empty_element(&self) -> bool {
9683        false
9684    }
9685}
9686
9687impl ToXml for CTCommonViewProperties {
9688    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
9689        #[allow(unused_mut)]
9690        let mut start = start;
9691        if let Some(ref val) = self.var_scale {
9692            start.push_attribute(("varScale", if *val { "1" } else { "0" }));
9693        }
9694        #[cfg(feature = "extra-attrs")]
9695        for (key, value) in &self.extra_attrs {
9696            start.push_attribute((key.as_str(), value.as_str()));
9697        }
9698        start
9699    }
9700
9701    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
9702        #[cfg(feature = "extra-children")]
9703        let mut extra_iter = self.extra_children.iter().peekable();
9704        #[cfg(feature = "extra-children")]
9705        let mut emit_idx: usize = 0;
9706        #[cfg(feature = "extra-children")]
9707        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9708            extra_iter
9709                .next()
9710                .unwrap()
9711                .node
9712                .write_to(writer)
9713                .map_err(SerializeError::from)?;
9714        }
9715        {
9716            let val = &self.scale;
9717            val.write_element("p:scale", writer)?;
9718        }
9719        #[cfg(feature = "extra-children")]
9720        {
9721            emit_idx += 1;
9722        }
9723        #[cfg(feature = "extra-children")]
9724        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9725            extra_iter
9726                .next()
9727                .unwrap()
9728                .node
9729                .write_to(writer)
9730                .map_err(SerializeError::from)?;
9731        }
9732        {
9733            let val = &self.origin;
9734            val.write_element("p:origin", writer)?;
9735        }
9736        #[cfg(feature = "extra-children")]
9737        {
9738            emit_idx += 1;
9739        }
9740        #[cfg(feature = "extra-children")]
9741        for extra in extra_iter {
9742            extra.node.write_to(writer).map_err(SerializeError::from)?;
9743        }
9744        Ok(())
9745    }
9746
9747    fn is_empty_element(&self) -> bool {
9748        false
9749    }
9750}
9751
9752impl ToXml for CTNotesTextViewProperties {
9753    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
9754        #[cfg(feature = "extra-children")]
9755        let mut extra_iter = self.extra_children.iter().peekable();
9756        #[cfg(feature = "extra-children")]
9757        let mut emit_idx: usize = 0;
9758        #[cfg(feature = "extra-children")]
9759        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9760            extra_iter
9761                .next()
9762                .unwrap()
9763                .node
9764                .write_to(writer)
9765                .map_err(SerializeError::from)?;
9766        }
9767        {
9768            let val = &self.c_view_pr;
9769            val.write_element("p:cViewPr", writer)?;
9770        }
9771        #[cfg(feature = "extra-children")]
9772        {
9773            emit_idx += 1;
9774        }
9775        #[cfg(feature = "extra-children")]
9776        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9777            extra_iter
9778                .next()
9779                .unwrap()
9780                .node
9781                .write_to(writer)
9782                .map_err(SerializeError::from)?;
9783        }
9784        if let Some(ref val) = self.ext_lst {
9785            val.write_element("p:extLst", writer)?;
9786        }
9787        #[cfg(feature = "extra-children")]
9788        {
9789            emit_idx += 1;
9790        }
9791        #[cfg(feature = "extra-children")]
9792        for extra in extra_iter {
9793            extra.node.write_to(writer).map_err(SerializeError::from)?;
9794        }
9795        Ok(())
9796    }
9797
9798    fn is_empty_element(&self) -> bool {
9799        false
9800    }
9801}
9802
9803impl ToXml for CTOutlineViewSlideEntry {
9804    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
9805        #[allow(unused_mut)]
9806        let mut start = start;
9807        if let Some(ref val) = self.collapse {
9808            start.push_attribute(("collapse", if *val { "1" } else { "0" }));
9809        }
9810        #[cfg(feature = "extra-attrs")]
9811        for (key, value) in &self.extra_attrs {
9812            start.push_attribute((key.as_str(), value.as_str()));
9813        }
9814        start
9815    }
9816
9817    fn is_empty_element(&self) -> bool {
9818        true
9819    }
9820}
9821
9822impl ToXml for CTOutlineViewSlideList {
9823    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
9824        #[cfg(feature = "extra-children")]
9825        let mut extra_iter = self.extra_children.iter().peekable();
9826        #[cfg(feature = "extra-children")]
9827        let mut emit_idx: usize = 0;
9828        for item in &self.sld {
9829            #[cfg(feature = "extra-children")]
9830            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9831                extra_iter
9832                    .next()
9833                    .unwrap()
9834                    .node
9835                    .write_to(writer)
9836                    .map_err(SerializeError::from)?;
9837            }
9838            item.write_element("p:sld", writer)?;
9839            #[cfg(feature = "extra-children")]
9840            {
9841                emit_idx += 1;
9842            }
9843        }
9844        #[cfg(feature = "extra-children")]
9845        for extra in extra_iter {
9846            extra.node.write_to(writer).map_err(SerializeError::from)?;
9847        }
9848        Ok(())
9849    }
9850
9851    fn is_empty_element(&self) -> bool {
9852        if !self.sld.is_empty() {
9853            return false;
9854        }
9855        #[cfg(feature = "extra-children")]
9856        if !self.extra_children.is_empty() {
9857            return false;
9858        }
9859        true
9860    }
9861}
9862
9863impl ToXml for CTOutlineViewProperties {
9864    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
9865        #[cfg(feature = "extra-children")]
9866        let mut extra_iter = self.extra_children.iter().peekable();
9867        #[cfg(feature = "extra-children")]
9868        let mut emit_idx: usize = 0;
9869        #[cfg(feature = "extra-children")]
9870        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9871            extra_iter
9872                .next()
9873                .unwrap()
9874                .node
9875                .write_to(writer)
9876                .map_err(SerializeError::from)?;
9877        }
9878        {
9879            let val = &self.c_view_pr;
9880            val.write_element("p:cViewPr", writer)?;
9881        }
9882        #[cfg(feature = "extra-children")]
9883        {
9884            emit_idx += 1;
9885        }
9886        #[cfg(feature = "extra-children")]
9887        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9888            extra_iter
9889                .next()
9890                .unwrap()
9891                .node
9892                .write_to(writer)
9893                .map_err(SerializeError::from)?;
9894        }
9895        if let Some(ref val) = self.sld_lst {
9896            val.write_element("p:sldLst", writer)?;
9897        }
9898        #[cfg(feature = "extra-children")]
9899        {
9900            emit_idx += 1;
9901        }
9902        #[cfg(feature = "extra-children")]
9903        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9904            extra_iter
9905                .next()
9906                .unwrap()
9907                .node
9908                .write_to(writer)
9909                .map_err(SerializeError::from)?;
9910        }
9911        if let Some(ref val) = self.ext_lst {
9912            val.write_element("p:extLst", writer)?;
9913        }
9914        #[cfg(feature = "extra-children")]
9915        {
9916            emit_idx += 1;
9917        }
9918        #[cfg(feature = "extra-children")]
9919        for extra in extra_iter {
9920            extra.node.write_to(writer).map_err(SerializeError::from)?;
9921        }
9922        Ok(())
9923    }
9924
9925    fn is_empty_element(&self) -> bool {
9926        false
9927    }
9928}
9929
9930impl ToXml for CTSlideSorterViewProperties {
9931    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
9932        #[allow(unused_mut)]
9933        let mut start = start;
9934        if let Some(ref val) = self.show_formatting {
9935            start.push_attribute(("showFormatting", if *val { "1" } else { "0" }));
9936        }
9937        #[cfg(feature = "extra-attrs")]
9938        for (key, value) in &self.extra_attrs {
9939            start.push_attribute((key.as_str(), value.as_str()));
9940        }
9941        start
9942    }
9943
9944    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
9945        #[cfg(feature = "extra-children")]
9946        let mut extra_iter = self.extra_children.iter().peekable();
9947        #[cfg(feature = "extra-children")]
9948        let mut emit_idx: usize = 0;
9949        #[cfg(feature = "extra-children")]
9950        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9951            extra_iter
9952                .next()
9953                .unwrap()
9954                .node
9955                .write_to(writer)
9956                .map_err(SerializeError::from)?;
9957        }
9958        {
9959            let val = &self.c_view_pr;
9960            val.write_element("p:cViewPr", writer)?;
9961        }
9962        #[cfg(feature = "extra-children")]
9963        {
9964            emit_idx += 1;
9965        }
9966        #[cfg(feature = "extra-children")]
9967        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
9968            extra_iter
9969                .next()
9970                .unwrap()
9971                .node
9972                .write_to(writer)
9973                .map_err(SerializeError::from)?;
9974        }
9975        if let Some(ref val) = self.ext_lst {
9976            val.write_element("p:extLst", writer)?;
9977        }
9978        #[cfg(feature = "extra-children")]
9979        {
9980            emit_idx += 1;
9981        }
9982        #[cfg(feature = "extra-children")]
9983        for extra in extra_iter {
9984            extra.node.write_to(writer).map_err(SerializeError::from)?;
9985        }
9986        Ok(())
9987    }
9988
9989    fn is_empty_element(&self) -> bool {
9990        false
9991    }
9992}
9993
9994impl ToXml for CTGuide {
9995    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
9996        #[allow(unused_mut)]
9997        let mut start = start;
9998        if let Some(ref val) = self.orient {
9999            {
10000                let s = val.to_string();
10001                start.push_attribute(("orient", s.as_str()));
10002            }
10003        }
10004        if let Some(ref val) = self.pos {
10005            {
10006                let s = val.to_string();
10007                start.push_attribute(("pos", s.as_str()));
10008            }
10009        }
10010        #[cfg(feature = "extra-attrs")]
10011        for (key, value) in &self.extra_attrs {
10012            start.push_attribute((key.as_str(), value.as_str()));
10013        }
10014        start
10015    }
10016
10017    fn is_empty_element(&self) -> bool {
10018        true
10019    }
10020}
10021
10022impl ToXml for CTGuideList {
10023    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
10024        #[cfg(feature = "extra-children")]
10025        let mut extra_iter = self.extra_children.iter().peekable();
10026        #[cfg(feature = "extra-children")]
10027        let mut emit_idx: usize = 0;
10028        for item in &self.guide {
10029            #[cfg(feature = "extra-children")]
10030            while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10031                extra_iter
10032                    .next()
10033                    .unwrap()
10034                    .node
10035                    .write_to(writer)
10036                    .map_err(SerializeError::from)?;
10037            }
10038            item.write_element("p:guide", writer)?;
10039            #[cfg(feature = "extra-children")]
10040            {
10041                emit_idx += 1;
10042            }
10043        }
10044        #[cfg(feature = "extra-children")]
10045        for extra in extra_iter {
10046            extra.node.write_to(writer).map_err(SerializeError::from)?;
10047        }
10048        Ok(())
10049    }
10050
10051    fn is_empty_element(&self) -> bool {
10052        if !self.guide.is_empty() {
10053            return false;
10054        }
10055        #[cfg(feature = "extra-children")]
10056        if !self.extra_children.is_empty() {
10057            return false;
10058        }
10059        true
10060    }
10061}
10062
10063impl ToXml for CTCommonSlideViewProperties {
10064    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
10065        #[allow(unused_mut)]
10066        let mut start = start;
10067        if let Some(ref val) = self.snap_to_grid {
10068            start.push_attribute(("snapToGrid", if *val { "1" } else { "0" }));
10069        }
10070        if let Some(ref val) = self.snap_to_objects {
10071            start.push_attribute(("snapToObjects", if *val { "1" } else { "0" }));
10072        }
10073        if let Some(ref val) = self.show_guides {
10074            start.push_attribute(("showGuides", if *val { "1" } else { "0" }));
10075        }
10076        #[cfg(feature = "extra-attrs")]
10077        for (key, value) in &self.extra_attrs {
10078            start.push_attribute((key.as_str(), value.as_str()));
10079        }
10080        start
10081    }
10082
10083    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
10084        #[cfg(feature = "extra-children")]
10085        let mut extra_iter = self.extra_children.iter().peekable();
10086        #[cfg(feature = "extra-children")]
10087        let mut emit_idx: usize = 0;
10088        #[cfg(feature = "extra-children")]
10089        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10090            extra_iter
10091                .next()
10092                .unwrap()
10093                .node
10094                .write_to(writer)
10095                .map_err(SerializeError::from)?;
10096        }
10097        {
10098            let val = &self.c_view_pr;
10099            val.write_element("p:cViewPr", writer)?;
10100        }
10101        #[cfg(feature = "extra-children")]
10102        {
10103            emit_idx += 1;
10104        }
10105        #[cfg(feature = "extra-children")]
10106        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10107            extra_iter
10108                .next()
10109                .unwrap()
10110                .node
10111                .write_to(writer)
10112                .map_err(SerializeError::from)?;
10113        }
10114        if let Some(ref val) = self.guide_lst {
10115            val.write_element("p:guideLst", writer)?;
10116        }
10117        #[cfg(feature = "extra-children")]
10118        {
10119            emit_idx += 1;
10120        }
10121        #[cfg(feature = "extra-children")]
10122        for extra in extra_iter {
10123            extra.node.write_to(writer).map_err(SerializeError::from)?;
10124        }
10125        Ok(())
10126    }
10127
10128    fn is_empty_element(&self) -> bool {
10129        false
10130    }
10131}
10132
10133impl ToXml for CTSlideViewProperties {
10134    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
10135        #[cfg(feature = "extra-children")]
10136        let mut extra_iter = self.extra_children.iter().peekable();
10137        #[cfg(feature = "extra-children")]
10138        let mut emit_idx: usize = 0;
10139        #[cfg(feature = "extra-children")]
10140        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10141            extra_iter
10142                .next()
10143                .unwrap()
10144                .node
10145                .write_to(writer)
10146                .map_err(SerializeError::from)?;
10147        }
10148        {
10149            let val = &self.c_sld_view_pr;
10150            val.write_element("p:cSldViewPr", writer)?;
10151        }
10152        #[cfg(feature = "extra-children")]
10153        {
10154            emit_idx += 1;
10155        }
10156        #[cfg(feature = "extra-children")]
10157        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10158            extra_iter
10159                .next()
10160                .unwrap()
10161                .node
10162                .write_to(writer)
10163                .map_err(SerializeError::from)?;
10164        }
10165        if let Some(ref val) = self.ext_lst {
10166            val.write_element("p:extLst", writer)?;
10167        }
10168        #[cfg(feature = "extra-children")]
10169        {
10170            emit_idx += 1;
10171        }
10172        #[cfg(feature = "extra-children")]
10173        for extra in extra_iter {
10174            extra.node.write_to(writer).map_err(SerializeError::from)?;
10175        }
10176        Ok(())
10177    }
10178
10179    fn is_empty_element(&self) -> bool {
10180        false
10181    }
10182}
10183
10184impl ToXml for CTNotesViewProperties {
10185    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
10186        #[cfg(feature = "extra-children")]
10187        let mut extra_iter = self.extra_children.iter().peekable();
10188        #[cfg(feature = "extra-children")]
10189        let mut emit_idx: usize = 0;
10190        #[cfg(feature = "extra-children")]
10191        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10192            extra_iter
10193                .next()
10194                .unwrap()
10195                .node
10196                .write_to(writer)
10197                .map_err(SerializeError::from)?;
10198        }
10199        {
10200            let val = &self.c_sld_view_pr;
10201            val.write_element("p:cSldViewPr", writer)?;
10202        }
10203        #[cfg(feature = "extra-children")]
10204        {
10205            emit_idx += 1;
10206        }
10207        #[cfg(feature = "extra-children")]
10208        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10209            extra_iter
10210                .next()
10211                .unwrap()
10212                .node
10213                .write_to(writer)
10214                .map_err(SerializeError::from)?;
10215        }
10216        if let Some(ref val) = self.ext_lst {
10217            val.write_element("p:extLst", writer)?;
10218        }
10219        #[cfg(feature = "extra-children")]
10220        {
10221            emit_idx += 1;
10222        }
10223        #[cfg(feature = "extra-children")]
10224        for extra in extra_iter {
10225            extra.node.write_to(writer).map_err(SerializeError::from)?;
10226        }
10227        Ok(())
10228    }
10229
10230    fn is_empty_element(&self) -> bool {
10231        false
10232    }
10233}
10234
10235impl ToXml for CTViewProperties {
10236    fn write_attrs<'a>(&self, start: BytesStart<'a>) -> BytesStart<'a> {
10237        #[allow(unused_mut)]
10238        let mut start = start;
10239        if let Some(ref val) = self.last_view {
10240            {
10241                let s = val.to_string();
10242                start.push_attribute(("lastView", s.as_str()));
10243            }
10244        }
10245        #[cfg(feature = "pml-comments")]
10246        if let Some(ref val) = self.show_comments {
10247            start.push_attribute(("showComments", if *val { "1" } else { "0" }));
10248        }
10249        #[cfg(feature = "extra-attrs")]
10250        for (key, value) in &self.extra_attrs {
10251            start.push_attribute((key.as_str(), value.as_str()));
10252        }
10253        start
10254    }
10255
10256    fn write_children<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), SerializeError> {
10257        #[cfg(feature = "extra-children")]
10258        let mut extra_iter = self.extra_children.iter().peekable();
10259        #[cfg(feature = "extra-children")]
10260        let mut emit_idx: usize = 0;
10261        #[cfg(feature = "extra-children")]
10262        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10263            extra_iter
10264                .next()
10265                .unwrap()
10266                .node
10267                .write_to(writer)
10268                .map_err(SerializeError::from)?;
10269        }
10270        if let Some(ref val) = self.normal_view_pr {
10271            val.write_element("p:normalViewPr", writer)?;
10272        }
10273        #[cfg(feature = "extra-children")]
10274        {
10275            emit_idx += 1;
10276        }
10277        #[cfg(feature = "extra-children")]
10278        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10279            extra_iter
10280                .next()
10281                .unwrap()
10282                .node
10283                .write_to(writer)
10284                .map_err(SerializeError::from)?;
10285        }
10286        if let Some(ref val) = self.slide_view_pr {
10287            val.write_element("p:slideViewPr", writer)?;
10288        }
10289        #[cfg(feature = "extra-children")]
10290        {
10291            emit_idx += 1;
10292        }
10293        #[cfg(feature = "extra-children")]
10294        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10295            extra_iter
10296                .next()
10297                .unwrap()
10298                .node
10299                .write_to(writer)
10300                .map_err(SerializeError::from)?;
10301        }
10302        if let Some(ref val) = self.outline_view_pr {
10303            val.write_element("p:outlineViewPr", writer)?;
10304        }
10305        #[cfg(feature = "extra-children")]
10306        {
10307            emit_idx += 1;
10308        }
10309        #[cfg(feature = "extra-children")]
10310        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10311            extra_iter
10312                .next()
10313                .unwrap()
10314                .node
10315                .write_to(writer)
10316                .map_err(SerializeError::from)?;
10317        }
10318        #[cfg(feature = "pml-notes")]
10319        if let Some(ref val) = self.notes_text_view_pr {
10320            val.write_element("p:notesTextViewPr", writer)?;
10321        }
10322        #[cfg(feature = "extra-children")]
10323        {
10324            emit_idx += 1;
10325        }
10326        #[cfg(feature = "extra-children")]
10327        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10328            extra_iter
10329                .next()
10330                .unwrap()
10331                .node
10332                .write_to(writer)
10333                .map_err(SerializeError::from)?;
10334        }
10335        if let Some(ref val) = self.sorter_view_pr {
10336            val.write_element("p:sorterViewPr", writer)?;
10337        }
10338        #[cfg(feature = "extra-children")]
10339        {
10340            emit_idx += 1;
10341        }
10342        #[cfg(feature = "extra-children")]
10343        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10344            extra_iter
10345                .next()
10346                .unwrap()
10347                .node
10348                .write_to(writer)
10349                .map_err(SerializeError::from)?;
10350        }
10351        #[cfg(feature = "pml-notes")]
10352        if let Some(ref val) = self.notes_view_pr {
10353            val.write_element("p:notesViewPr", writer)?;
10354        }
10355        #[cfg(feature = "extra-children")]
10356        {
10357            emit_idx += 1;
10358        }
10359        #[cfg(feature = "extra-children")]
10360        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10361            extra_iter
10362                .next()
10363                .unwrap()
10364                .node
10365                .write_to(writer)
10366                .map_err(SerializeError::from)?;
10367        }
10368        if let Some(ref val) = self.grid_spacing {
10369            val.write_element("p:gridSpacing", writer)?;
10370        }
10371        #[cfg(feature = "extra-children")]
10372        {
10373            emit_idx += 1;
10374        }
10375        #[cfg(feature = "extra-children")]
10376        while extra_iter.peek().is_some_and(|e| e.position <= emit_idx) {
10377            extra_iter
10378                .next()
10379                .unwrap()
10380                .node
10381                .write_to(writer)
10382                .map_err(SerializeError::from)?;
10383        }
10384        #[cfg(feature = "pml-extensions")]
10385        if let Some(ref val) = self.ext_lst {
10386            val.write_element("p:extLst", writer)?;
10387        }
10388        #[cfg(feature = "extra-children")]
10389        {
10390            emit_idx += 1;
10391        }
10392        #[cfg(feature = "extra-children")]
10393        for extra in extra_iter {
10394            extra.node.write_to(writer).map_err(SerializeError::from)?;
10395        }
10396        Ok(())
10397    }
10398
10399    fn is_empty_element(&self) -> bool {
10400        if self.normal_view_pr.is_some() {
10401            return false;
10402        }
10403        if self.slide_view_pr.is_some() {
10404            return false;
10405        }
10406        if self.outline_view_pr.is_some() {
10407            return false;
10408        }
10409        #[cfg(feature = "pml-notes")]
10410        if self.notes_text_view_pr.is_some() {
10411            return false;
10412        }
10413        if self.sorter_view_pr.is_some() {
10414            return false;
10415        }
10416        #[cfg(feature = "pml-notes")]
10417        if self.notes_view_pr.is_some() {
10418            return false;
10419        }
10420        if self.grid_spacing.is_some() {
10421            return false;
10422        }
10423        #[cfg(feature = "pml-extensions")]
10424        if self.ext_lst.is_some() {
10425            return false;
10426        }
10427        #[cfg(feature = "extra-children")]
10428        if !self.extra_children.is_empty() {
10429            return false;
10430        }
10431        true
10432    }
10433}