Struct docx_rust::styles::Style

pub struct Style<'a> {
    pub ty: StyleType,
    pub default: Option<usize>,
    pub style_id: Cow<'a, str>,
    pub name: Option<StyleName<'a>>,
    pub q_format: Option<QFormat>,
    pub priority: Option<Priority>,
    pub semi_hidden: Option<SemiHidden>,
    pub unhide_when_used: Option<UnhideWhenUsed>,
    pub paragraph: Option<ParagraphProperty<'a>>,
    pub character: Option<CharacterProperty<'a>>,
    pub table: Option<TableProperty<'a>>,
}

Style

A style that applied to a region of the document.

use docx::formatting::*;
use docx::styles::*;

let style = Style::new(StyleType::Paragraph, "style_id")
    .name("Style Name")
    .paragraph(ParagraphProperty::default())
    .character(CharacterProperty::default());

Fields

ty: StyleType

Specifies the type of style.

default: Option<usize>

style_id: Cow<'a, str>

Specifies the unique identifier

This identifier is used throughout the document to apply style in content.

name: Option<StyleName<'a>>

Specifies the primary name

q_format: Option<QFormat>

priority: Option<Priority>

Specifies the priority.

semi_hidden: Option<SemiHidden>

unhide_when_used: Option<UnhideWhenUsed>

paragraph: Option<ParagraphProperty<'a>>

Specifies a set of paragraph properties

character: Option<CharacterProperty<'a>>

Specifies a set of character properties

table: Option<TableProperty<'a>>

Implementations

impl<'a> Style<'a>

pub fn new<T: Into<Cow<'a, str>>>(ty: StyleType, style_id: T) -> Self

pub fn ty<T: Into<StyleType>>(self, value: T) -> Self

pub fn name<T: Into<StyleName<'a>>>(self, value: T) -> Self

pub fn paragraph<T: Into<ParagraphProperty<'a>>>(self, value: T) -> Self

pub fn character<T: Into<CharacterProperty<'a>>>(self, value: T) -> Self

Trait Implementations

impl<'a> Clone for Style<'a>

fn clone(&self) -> Style<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Style<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'__input: 'a, 'a> XmlRead<'__input> for Style<'a>

fn from_reader(reader: &mut XmlReader<'__input>) -> XmlResult<Self>

fn from_str(text: &'a str) -> Result<Self, XmlError>

impl<'a> XmlWrite for Style<'a>

fn to_writer<W: Write>(&self, writer: &mut XmlWriter<W>) -> XmlResult<()>

fn to_string(&self) -> Result<String, XmlError>