docx_reader/documents/elements/
table_cell.rs

1use serde::ser::{SerializeStruct, Serializer};
2use serde::Serialize;
3
4use super::*;
5use crate::types::*;
6
7#[derive(Serialize, Debug, Clone, PartialEq)]
8#[serde(rename_all = "camelCase")]
9pub struct TableCell {
10	pub children: Vec<TableCellContent>,
11	pub property: TableCellProperty,
12	pub has_numbering: bool,
13}
14
15#[derive(Debug, Clone, PartialEq)]
16pub enum TableCellContent {
17	Paragraph(Paragraph),
18	Table(Table),
19	StructuredDataTag(Box<StructuredDataTag>),
20	TableOfContents(Box<TableOfContents>),
21}
22
23impl Serialize for TableCellContent {
24	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
25	where
26		S: Serializer,
27	{
28		match *self {
29			TableCellContent::Paragraph(ref s) => {
30				let mut t = serializer.serialize_struct("Paragraph", 2)?;
31				t.serialize_field("type", "paragraph")?;
32				t.serialize_field("data", s)?;
33				t.end()
34			}
35			TableCellContent::Table(ref s) => {
36				let mut t = serializer.serialize_struct("Table", 2)?;
37				t.serialize_field("type", "table")?;
38				t.serialize_field("data", s)?;
39				t.end()
40			}
41			TableCellContent::StructuredDataTag(ref r) => {
42				let mut t = serializer.serialize_struct("StructuredDataTag", 2)?;
43				t.serialize_field("type", "structuredDataTag")?;
44				t.serialize_field("data", r)?;
45				t.end()
46			}
47			TableCellContent::TableOfContents(ref r) => {
48				let mut t = serializer.serialize_struct("TableOfContents", 2)?;
49				t.serialize_field("type", "tableOfContents")?;
50				t.serialize_field("data", r)?;
51				t.end()
52			}
53		}
54	}
55}
56
57impl TableCell {
58	pub fn new() -> TableCell {
59		Default::default()
60	}
61
62	pub fn add_paragraph(mut self, p: Paragraph) -> TableCell {
63		if p.has_numbering {
64			self.has_numbering = true
65		}
66		self.children.push(TableCellContent::Paragraph(p));
67		self
68	}
69
70	pub fn add_table_of_contents(mut self, t: TableOfContents) -> Self {
71		self.children
72			.push(TableCellContent::TableOfContents(Box::new(t)));
73		self
74	}
75
76	pub fn add_structured_data_tag(mut self, t: StructuredDataTag) -> Self {
77		self.children
78			.push(TableCellContent::StructuredDataTag(Box::new(t)));
79		self
80	}
81
82	pub fn add_table(mut self, t: Table) -> TableCell {
83		if t.has_numbering {
84			self.has_numbering = true
85		}
86		self.children.push(TableCellContent::Table(t));
87		self
88	}
89
90	pub fn vertical_merge(mut self, t: VMergeType) -> TableCell {
91		self.property = self.property.vertical_merge(t);
92		self
93	}
94
95	pub fn shading(mut self, s: Shading) -> TableCell {
96		self.property = self.property.shading(s);
97		self
98	}
99
100	pub fn vertical_align(mut self, t: VAlignType) -> TableCell {
101		self.property = self.property.vertical_align(t);
102		self
103	}
104
105	pub fn text_direction(mut self, t: TextDirectionType) -> TableCell {
106		self.property = self.property.text_direction(t);
107		self
108	}
109
110	pub fn grid_span(mut self, v: usize) -> TableCell {
111		self.property = self.property.grid_span(v);
112		self
113	}
114
115	pub fn width(mut self, v: usize, t: WidthType) -> TableCell {
116		self.property = self.property.width(v, t);
117		self
118	}
119
120	pub fn set_border(mut self, border: TableCellBorder) -> Self {
121		self.property = self.property.set_border(border);
122		self
123	}
124
125	pub fn set_borders(mut self, borders: TableCellBorders) -> Self {
126		self.property = self.property.set_borders(borders);
127		self
128	}
129
130	pub fn clear_border(mut self, position: TableCellBorderPosition) -> Self {
131		self.property = self.property.clear_border(position);
132		self
133	}
134
135	pub fn clear_all_border(mut self) -> Self {
136		self.property = self.property.clear_all_border();
137		self
138	}
139}
140
141impl Default for TableCell {
142	fn default() -> Self {
143		let property = TableCellProperty::new();
144		let children = vec![];
145		Self {
146			property,
147			children,
148			has_numbering: false,
149		}
150	}
151}