docx_reader/documents/elements/
table_cell.rs1use 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}