Skip to main content

excelize_rs/xml/
styles.rs

1//! Styles part (`xl/styles.xml`).
2//!
3//! Ported from Go `xmlStyles.go`.
4
5use serde::{Deserialize, Serialize};
6
7use super::common::{
8    AttrValBool, AttrValFloat, AttrValInt, AttrValString, XlsxColor, XlsxExtLst, XlsxInnerXml,
9};
10use super::drawing::XlsxPositiveSize2D;
11
12/// Directly maps the root element of the Styles part.
13#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
14#[serde(rename = "styleSheet")]
15pub struct XlsxStyleSheet {
16    #[serde(rename = "@xmlns", default)]
17    pub xmlns: Option<String>,
18    #[serde(rename = "numFmts", default)]
19    pub num_fmts: Option<XlsxNumFmts>,
20    #[serde(rename = "fonts", default)]
21    pub fonts: Option<XlsxFonts>,
22    #[serde(rename = "fills", default)]
23    pub fills: Option<XlsxFills>,
24    #[serde(rename = "borders", default)]
25    pub borders: Option<XlsxBorders>,
26    #[serde(rename = "cellStyleXfs", default)]
27    pub cell_style_xfs: Option<XlsxCellStyleXfs>,
28    #[serde(rename = "cellXfs", default)]
29    pub cell_xfs: Option<XlsxCellXfs>,
30    #[serde(rename = "cellStyles", default)]
31    pub cell_styles: Option<XlsxCellStyles>,
32    #[serde(rename = "dxfs", default)]
33    pub dxfs: Option<XlsxDxfs>,
34    #[serde(rename = "tableStyles", default)]
35    pub table_styles: Option<XlsxTableStyles>,
36    #[serde(rename = "colors", default)]
37    pub colors: Option<XlsxStyleColors>,
38    #[serde(rename = "extLst", default)]
39    pub ext_lst: Option<XlsxExtLst>,
40}
41
42/// Formatting information pertaining to text alignment in cells.
43#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
44pub struct XlsxAlignment {
45    #[serde(rename = "@horizontal", default)]
46    pub horizontal: Option<String>,
47    #[serde(rename = "@indent", default)]
48    pub indent: Option<i64>,
49    #[serde(rename = "@justifyLastLine", default)]
50    pub justify_last_line: Option<bool>,
51    #[serde(rename = "@readingOrder", default)]
52    pub reading_order: Option<u64>,
53    #[serde(rename = "@relativeIndent", default)]
54    pub relative_indent: Option<i64>,
55    #[serde(rename = "@shrinkToFit", default)]
56    pub shrink_to_fit: Option<bool>,
57    #[serde(rename = "@textRotation", default)]
58    pub text_rotation: Option<i64>,
59    #[serde(rename = "@vertical", default)]
60    pub vertical: Option<String>,
61    #[serde(rename = "@wrapText", default)]
62    pub wrap_text: Option<bool>,
63}
64
65/// Protection properties associated with a cell.
66#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
67pub struct XlsxProtection {
68    #[serde(rename = "@hidden", default)]
69    pub hidden: Option<bool>,
70    #[serde(rename = "@locked", default)]
71    pub locked: Option<bool>,
72}
73
74/// A single set of cell border.
75#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
76pub struct XlsxLine {
77    #[serde(rename = "@style", default)]
78    pub style: Option<String>,
79    #[serde(rename = "color", default)]
80    pub color: Option<XlsxColor>,
81}
82
83/// Directly maps the fonts element.
84#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
85#[serde(rename = "fonts")]
86pub struct XlsxFonts {
87    #[serde(rename = "@count", default)]
88    pub count: i64,
89    #[serde(rename = "font", default)]
90    pub font: Vec<XlsxFont>,
91}
92
93/// Directly maps the font element.
94#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
95pub struct XlsxFont {
96    #[serde(rename = "name", default)]
97    pub name: Option<AttrValString>,
98    #[serde(rename = "charset", default)]
99    pub charset: Option<AttrValInt>,
100    #[serde(rename = "family", default)]
101    pub family: Option<AttrValInt>,
102    #[serde(rename = "b", default)]
103    pub b: Option<AttrValBool>,
104    #[serde(rename = "i", default)]
105    pub i: Option<AttrValBool>,
106    #[serde(rename = "strike", default)]
107    pub strike: Option<AttrValBool>,
108    #[serde(rename = "outline", default)]
109    pub outline: Option<AttrValBool>,
110    #[serde(rename = "shadow", default)]
111    pub shadow: Option<AttrValBool>,
112    #[serde(rename = "condense", default)]
113    pub condense: Option<AttrValBool>,
114    #[serde(rename = "extend", default)]
115    pub extend: Option<AttrValBool>,
116    #[serde(rename = "color", default)]
117    pub color: Option<XlsxColor>,
118    #[serde(rename = "sz", default)]
119    pub sz: Option<AttrValFloat>,
120    #[serde(rename = "u", default)]
121    pub u: Option<AttrValString>,
122    #[serde(rename = "vertAlign", default)]
123    pub vert_align: Option<AttrValString>,
124    #[serde(rename = "scheme", default)]
125    pub scheme: Option<AttrValString>,
126}
127
128/// Directly maps the fills element.
129#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
130#[serde(rename = "fills")]
131pub struct XlsxFills {
132    #[serde(rename = "@count", default)]
133    pub count: i64,
134    #[serde(rename = "fill", default)]
135    pub fill: Vec<XlsxFill>,
136}
137
138/// Directly maps the fill element.
139#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
140pub struct XlsxFill {
141    #[serde(rename = "patternFill", default)]
142    pub pattern_fill: Option<XlsxPatternFill>,
143    #[serde(rename = "gradientFill", default)]
144    pub gradient_fill: Option<XlsxGradientFill>,
145}
146
147/// Cell fill information for pattern and solid color cell fills.
148#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
149pub struct XlsxPatternFill {
150    #[serde(rename = "@patternType", default)]
151    pub pattern_type: Option<String>,
152    #[serde(rename = "fgColor", default)]
153    pub fg_color: Option<XlsxColor>,
154    #[serde(rename = "bgColor", default)]
155    pub bg_color: Option<XlsxColor>,
156}
157
158/// A gradient-style cell fill.
159#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
160pub struct XlsxGradientFill {
161    #[serde(rename = "@bottom", default)]
162    pub bottom: Option<f64>,
163    #[serde(rename = "@degree", default)]
164    pub degree: Option<f64>,
165    #[serde(rename = "@left", default)]
166    pub left: Option<f64>,
167    #[serde(rename = "@right", default)]
168    pub right: Option<f64>,
169    #[serde(rename = "@top", default)]
170    pub top: Option<f64>,
171    #[serde(rename = "@type", default)]
172    pub r#type: Option<String>,
173    #[serde(rename = "stop", default)]
174    pub stop: Vec<XlsxGradientFillStop>,
175}
176
177/// A single gradient stop.
178#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
179pub struct XlsxGradientFillStop {
180    #[serde(rename = "@position")]
181    pub position: f64,
182    #[serde(rename = "color", default)]
183    pub color: Option<XlsxColor>,
184}
185
186/// Directly maps the borders element.
187#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
188#[serde(rename = "borders")]
189pub struct XlsxBorders {
190    #[serde(rename = "@count", default)]
191    pub count: i64,
192    #[serde(rename = "border", default)]
193    pub border: Vec<XlsxBorder>,
194}
195
196/// A single set of cell border formats.
197#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
198pub struct XlsxBorder {
199    #[serde(rename = "@diagonalDown", default)]
200    pub diagonal_down: Option<bool>,
201    #[serde(rename = "@diagonalUp", default)]
202    pub diagonal_up: Option<bool>,
203    #[serde(rename = "@outline", default)]
204    pub outline: Option<bool>,
205    #[serde(rename = "left", default)]
206    pub left: Option<XlsxLine>,
207    #[serde(rename = "right", default)]
208    pub right: Option<XlsxLine>,
209    #[serde(rename = "top", default)]
210    pub top: Option<XlsxLine>,
211    #[serde(rename = "bottom", default)]
212    pub bottom: Option<XlsxLine>,
213    #[serde(rename = "diagonal", default)]
214    pub diagonal: Option<XlsxLine>,
215    #[serde(rename = "vertical", default)]
216    pub vertical: Option<XlsxLine>,
217    #[serde(rename = "horizontal", default)]
218    pub horizontal: Option<XlsxLine>,
219}
220
221/// Directly maps the cellStyles element.
222#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
223#[serde(rename = "cellStyles")]
224pub struct XlsxCellStyles {
225    #[serde(rename = "@count", default)]
226    pub count: i64,
227    #[serde(rename = "cellStyle", default)]
228    pub cell_style: Vec<XlsxCellStyle>,
229}
230
231/// A named cell style.
232#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
233#[serde(rename = "cellStyle")]
234pub struct XlsxCellStyle {
235    #[serde(rename = "@name")]
236    pub name: String,
237    #[serde(rename = "@xfId")]
238    pub xf_id: i64,
239    #[serde(rename = "@builtinId", default)]
240    pub built_in_id: Option<i64>,
241    #[serde(rename = "@iLevel", default)]
242    pub i_level: Option<i64>,
243    #[serde(rename = "@hidden", default)]
244    pub hidden: Option<bool>,
245    #[serde(rename = "@customBuiltin", default)]
246    pub custom_built_in: Option<bool>,
247}
248
249/// Directly maps the cellStyleXfs element.
250#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
251#[serde(rename = "cellStyleXfs")]
252pub struct XlsxCellStyleXfs {
253    #[serde(rename = "@count", default)]
254    pub count: i64,
255    #[serde(rename = "xf", default)]
256    pub xf: Vec<XlsxXf>,
257}
258
259/// A single xf element describing all formatting for a cell.
260#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
261pub struct XlsxXf {
262    #[serde(rename = "@numFmtId", default)]
263    pub num_fmt_id: Option<i64>,
264    #[serde(rename = "@fontId", default)]
265    pub font_id: Option<i64>,
266    #[serde(rename = "@fillId", default)]
267    pub fill_id: Option<i64>,
268    #[serde(rename = "@borderId", default)]
269    pub border_id: Option<i64>,
270    #[serde(rename = "@xfId", default)]
271    pub xf_id: Option<i64>,
272    #[serde(rename = "@quotePrefix", default)]
273    pub quote_prefix: Option<bool>,
274    #[serde(rename = "@pivotButton", default)]
275    pub pivot_button: Option<bool>,
276    #[serde(rename = "@applyNumberFormat", default)]
277    pub apply_number_format: Option<bool>,
278    #[serde(rename = "@applyFont", default)]
279    pub apply_font: Option<bool>,
280    #[serde(rename = "@applyFill", default)]
281    pub apply_fill: Option<bool>,
282    #[serde(rename = "@applyBorder", default)]
283    pub apply_border: Option<bool>,
284    #[serde(rename = "@applyAlignment", default)]
285    pub apply_alignment: Option<bool>,
286    #[serde(rename = "@applyProtection", default)]
287    pub apply_protection: Option<bool>,
288    #[serde(rename = "alignment", default)]
289    pub alignment: Option<XlsxAlignment>,
290    #[serde(rename = "protection", default)]
291    pub protection: Option<XlsxProtection>,
292}
293
294/// Directly maps the cellXfs element.
295#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
296#[serde(rename = "cellXfs")]
297pub struct XlsxCellXfs {
298    #[serde(rename = "@count", default)]
299    pub count: i64,
300    #[serde(rename = "xf", default)]
301    pub xf: Vec<XlsxXf>,
302}
303
304/// Directly maps the dxfs element.
305#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
306#[serde(rename = "dxfs")]
307pub struct XlsxDxfs {
308    #[serde(rename = "@count", default)]
309    pub count: i64,
310    #[serde(rename = "dxf", default)]
311    pub dxfs: Vec<XlsxDxf>,
312}
313
314/// A single dxf record expressing incremental formatting.
315#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
316pub struct XlsxDxf {
317    #[serde(rename = "font", default)]
318    pub font: Option<XlsxFont>,
319    #[serde(rename = "numFmt", default)]
320    pub num_fmt: Option<XlsxNumFmt>,
321    #[serde(rename = "fill", default)]
322    pub fill: Option<XlsxFill>,
323    #[serde(rename = "alignment", default)]
324    pub alignment: Option<XlsxAlignment>,
325    #[serde(rename = "border", default)]
326    pub border: Option<XlsxBorder>,
327    #[serde(rename = "protection", default)]
328    pub protection: Option<XlsxProtection>,
329    #[serde(rename = "extLst", default)]
330    pub ext_lst: Option<XlsxPositiveSize2D>,
331}
332
333/// Directly maps the tableStyles element.
334#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
335#[serde(rename = "tableStyles")]
336pub struct XlsxTableStyles {
337    #[serde(rename = "@count", default)]
338    pub count: i64,
339    #[serde(rename = "@defaultPivotStyle")]
340    pub default_pivot_style: String,
341    #[serde(rename = "@defaultTableStyle")]
342    pub default_table_style: String,
343    #[serde(rename = "tableStyle", default)]
344    pub table_styles: Vec<XlsxTableStyle>,
345}
346
347/// A single table style definition.
348#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
349#[serde(rename = "tableStyle")]
350pub struct XlsxTableStyle {
351    #[serde(rename = "@name", default)]
352    pub name: Option<String>,
353    #[serde(rename = "@pivot", default)]
354    pub pivot: i64,
355    #[serde(rename = "@count", default)]
356    pub count: i64,
357    #[serde(rename = "@table", default)]
358    pub table: Option<bool>,
359    #[serde(rename = "$value", default)]
360    pub table_style_element: String,
361}
362
363/// Directly maps the numFmts element.
364#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
365#[serde(rename = "numFmts")]
366pub struct XlsxNumFmts {
367    #[serde(rename = "@count", default)]
368    pub count: i64,
369    #[serde(rename = "numFmt", default)]
370    pub num_fmt: Vec<XlsxNumFmt>,
371}
372
373/// Directly maps the numFmt element.
374#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)]
375pub struct XlsxNumFmt {
376    #[serde(rename = "@numFmtId")]
377    pub num_fmt_id: i64,
378    #[serde(rename = "@formatCode")]
379    pub format_code: String,
380    #[serde(
381        rename = "http://schemas.microsoft.com/office/spreadsheetml/2015/02/main formatCode16",
382        default
383    )]
384    pub format_code_16: Option<String>,
385}
386
387/// A single ARGB entry for the corresponding color index.
388#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
389pub struct XlsxIndexedColors {
390    #[serde(rename = "rgbColor", default)]
391    pub rgb_color: Vec<XlsxColor>,
392}
393
394/// Color information associated with the style sheet.
395#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
396#[serde(rename = "colors")]
397pub struct XlsxStyleColors {
398    #[serde(rename = "indexedColors", default)]
399    pub indexed_colors: Option<XlsxIndexedColors>,
400    #[serde(rename = "mruColors", default)]
401    pub mru_colors: Option<XlsxInnerXml>,
402}