docx_reader/documents/elements/
paragraph.rsuse serde::ser::{SerializeStruct, Serializer};
use serde::Serialize;
use super::*;
use crate::types::*;
#[derive(Serialize, Debug, Clone, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct Paragraph {
pub id: String,
pub children: Vec<ParagraphChild>,
pub property: ParagraphProperty,
pub has_numbering: bool,
}
impl Default for Paragraph {
fn default() -> Self {
Self {
id: crate::generate_para_id(),
children: Vec::new(),
property: ParagraphProperty::new(),
has_numbering: false,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub enum ParagraphChild {
Run(Box<Run>),
Insert(Insert),
Delete(Delete),
Hyperlink(Hyperlink),
StructuredDataTag(Box<StructuredDataTag>),
}
impl Serialize for ParagraphChild {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match *self {
ParagraphChild::Run(ref r) => {
let mut t = serializer.serialize_struct("Run", 2)?;
t.serialize_field("type", "run")?;
t.serialize_field("data", r)?;
t.end()
}
ParagraphChild::Insert(ref r) => {
let mut t = serializer.serialize_struct("Insert", 2)?;
t.serialize_field("type", "insert")?;
t.serialize_field("data", r)?;
t.end()
}
ParagraphChild::Delete(ref r) => {
let mut t = serializer.serialize_struct("Delete", 2)?;
t.serialize_field("type", "delete")?;
t.serialize_field("data", r)?;
t.end()
}
ParagraphChild::Hyperlink(ref r) => {
let mut t = serializer.serialize_struct("hyperlink", 2)?;
t.serialize_field("type", "hyperlink")?;
t.serialize_field("data", r)?;
t.end()
}
ParagraphChild::StructuredDataTag(ref r) => {
let mut t = serializer.serialize_struct("StructuredDataTag", 2)?;
t.serialize_field("type", "structuredDataTag")?;
t.serialize_field("data", r)?;
t.end()
}
}
}
}
impl Paragraph {
pub fn new() -> Paragraph {
Default::default()
}
pub fn id(mut self, id: impl Into<String>) -> Self {
self.id = id.into();
self
}
pub fn children(&self) -> &Vec<ParagraphChild> {
&self.children
}
pub fn add_run(mut self, run: Run) -> Paragraph {
self.children.push(ParagraphChild::Run(Box::new(run)));
self
}
pub fn add_hyperlink(mut self, link: Hyperlink) -> Self {
self.children.push(ParagraphChild::Hyperlink(link));
self
}
pub fn add_structured_data_tag(mut self, t: StructuredDataTag) -> Self {
self.children
.push(ParagraphChild::StructuredDataTag(Box::new(t)));
self
}
pub fn add_insert(mut self, insert: Insert) -> Paragraph {
self.children.push(ParagraphChild::Insert(insert));
self
}
pub fn add_delete(mut self, delete: Delete) -> Paragraph {
self.children.push(ParagraphChild::Delete(delete));
self
}
pub fn align(mut self, alignment_type: AlignmentType) -> Paragraph {
self.property = self.property.align(alignment_type);
self
}
pub fn style(mut self, style_id: &str) -> Paragraph {
self.property = self.property.style(style_id);
self
}
pub fn keep_next(mut self, v: bool) -> Self {
self.property = self.property.keep_next(v);
self
}
pub fn keep_lines(mut self, v: bool) -> Self {
self.property = self.property.keep_lines(v);
self
}
pub fn outline_lvl(mut self, v: usize) -> Self {
self.property = self.property.outline_lvl(v);
self
}
pub fn page_break_before(mut self, v: bool) -> Self {
self.property = self.property.page_break_before(v);
self
}
pub fn widow_control(mut self, v: bool) -> Self {
self.property = self.property.widow_control(v);
self
}
pub fn section_property(mut self, s: SectionProperty) -> Self {
self.property = self.property.section_property(s);
self
}
pub fn add_tab(mut self, t: Tab) -> Self {
self.property = self.property.add_tab(t);
self
}
pub fn indent(
mut self,
left: Option<i32>,
special_indent: Option<SpecialIndentType>,
end: Option<i32>,
start_chars: Option<i32>,
) -> Paragraph {
self.property = self.property.indent(left, special_indent, end, start_chars);
self
}
pub fn hanging_chars(mut self, chars: i32) -> Paragraph {
self.property = self.property.hanging_chars(chars);
self
}
pub fn first_line_chars(mut self, chars: i32) -> Paragraph {
self.property = self.property.first_line_chars(chars);
self
}
pub fn numbering(mut self, id: NumberingId, level: IndentLevel) -> Self {
self.property = self.property.numbering(id, level);
self.has_numbering = true;
self
}
pub fn size(mut self, size: usize) -> Self {
self.property.run_property = self.property.run_property.size(size);
self
}
pub fn bold(mut self) -> Self {
self.property.run_property = self.property.run_property.bold();
self
}
pub fn italic(mut self) -> Self {
self.property.run_property = self.property.run_property.italic();
self
}
pub fn fonts(mut self, f: RunFonts) -> Self {
self.property.run_property = self.property.run_property.fonts(f);
self
}
pub fn run_property(mut self, p: RunProperty) -> Self {
self.property.run_property = p;
self
}
pub fn line_spacing(mut self, spacing: LineSpacing) -> Self {
self.property = self.property.line_spacing(spacing);
self
}
pub fn character_spacing(mut self, spacing: i32) -> Self {
self.property = self.property.character_spacing(spacing);
self
}
pub fn delete(mut self, author: impl Into<String>, date: impl Into<String>) -> Self {
self.property.run_property.del = Some(Delete::new().author(author).date(date));
self
}
pub fn insert(mut self, author: impl Into<String>, date: impl Into<String>) -> Self {
self.property.run_property.ins = Some(Insert::new_with_empty().author(author).date(date));
self
}
pub fn paragraph_property_change(mut self, p: ParagraphPropertyChange) -> Self {
self.property = self.property.paragraph_property_change(p);
self
}
pub fn raw_text(&self) -> String {
let mut s = "".to_string();
for c in self.children.iter() {
match c {
ParagraphChild::Insert(i) => {
for c in i.children.iter() {
if let InsertChild::Run(r) = c {
for c in r.children.iter() {
if let RunChild::Text(t) = c {
s.push_str(&t.text);
}
}
}
}
}
ParagraphChild::Run(run) => {
for c in run.children.iter() {
if let RunChild::Text(t) = c {
s.push_str(&t.text);
}
}
}
_ => {}
}
}
s
}
}