umya-spreadsheet 3.0.0

umya-spreadsheet is a library written in pure Rust to read and write xlsx file.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

// c:printSettings
use std::io::Cursor;

use quick_xml::{
    Reader,
    Writer,
    events::{
        BytesStart,
        Event,
    },
};

use super::{
    HeaderFooter,
    PageMargins,
    PageSetup,
};
use crate::{
    reader::driver::xml_read_loop,
    writer::driver::{
        write_end_tag,
        write_start_tag,
    },
};

#[derive(Clone, Default, Debug)]
pub struct PrintSettings {
    header_footer: HeaderFooter,
    page_margins:  PageMargins,
    page_setup:    PageSetup,
}

impl PrintSettings {
    #[must_use]
    pub fn header_footer(&self) -> &HeaderFooter {
        &self.header_footer
    }

    #[must_use]
    #[deprecated(since = "3.0.0", note = "Use header_footer()")]
    pub fn get_header_footer(&self) -> &HeaderFooter {
        self.header_footer()
    }

    pub fn header_footer_mut(&mut self) -> &mut HeaderFooter {
        &mut self.header_footer
    }

    #[deprecated(since = "3.0.0", note = "Use header_footer_mut()")]
    pub fn get_header_footer_mut(&mut self) -> &mut HeaderFooter {
        self.header_footer_mut()
    }

    pub fn set_header_footer(&mut self, value: HeaderFooter) -> &mut Self {
        self.header_footer = value;
        self
    }

    #[must_use]
    pub fn page_margins(&self) -> &PageMargins {
        &self.page_margins
    }

    #[must_use]
    #[deprecated(since = "3.0.0", note = "Use page_margins()")]
    pub fn get_page_margins(&self) -> &PageMargins {
        self.page_margins()
    }

    pub fn page_margins_mut(&mut self) -> &mut PageMargins {
        &mut self.page_margins
    }

    #[deprecated(since = "3.0.0", note = "Use page_margins_mut()")]
    pub fn get_page_margins_mut(&mut self) -> &mut PageMargins {
        self.page_margins_mut()
    }

    pub fn set_page_margins(&mut self, value: PageMargins) -> &mut Self {
        self.page_margins = value;
        self
    }

    #[must_use]
    pub fn page_setup(&self) -> &PageSetup {
        &self.page_setup
    }

    #[must_use]
    #[deprecated(since = "3.0.0", note = "Use page_setup()")]
    pub fn get_page_setup(&self) -> &PageSetup {
        self.page_setup()
    }

    pub fn page_setup_mut(&mut self) -> &mut PageSetup {
        &mut self.page_setup
    }

    #[deprecated(since = "3.0.0", note = "Use page_setup_mut()")]
    pub fn get_page_setup_mut(&mut self) -> &mut PageSetup {
        self.page_setup_mut()
    }

    pub fn set_page_setup(&mut self, value: PageSetup) -> &mut Self {
        self.page_setup = value;
        self
    }

    pub(crate) fn set_attributes<R: std::io::BufRead>(
        &mut self,
        reader: &mut Reader<R>,
        _e: &BytesStart,
    ) {
        xml_read_loop!(
            reader,
            Event::Start(ref e) => {
                match e.name().0 {
                b"c:headerFooter" => {
                    HeaderFooter::set_attributes(reader, e);
                }
                b"c:pageSetup" => {
                    PageSetup::set_attributes(reader, e);
                }
                _ => (),
                }
            },
            Event::Empty(ref e) => {
                if e.name().0 == b"c:pageMargins" {
                    self.page_margins.set_attributes(reader, e);
                }
            },
            Event::End(ref e) => {
                if e.name().0 == b"c:printSettings" {
                    return;
                }
            },
            Event::Eof => panic!("Error: Could not find {} end element", "c:printSettings")
        );
    }

    pub(crate) fn write_to(&self, writer: &mut Writer<Cursor<Vec<u8>>>) {
        // c:printSettings
        write_start_tag(writer, "c:printSettings", vec![], false);

        // c:headerFooter
        HeaderFooter::write_to(writer);

        // c:pageMargins
        self.page_margins.write_to(writer);

        // c:pageSetup
        PageSetup::write_to(writer);

        write_end_tag(writer, "c:printSettings");
    }
}