Struct StyleTree 

pub struct StyleTree { /* private fields */ }

The compiled styling of one book.

Implementations

impl StyleTree

pub fn style(&self, id: NodeId) -> &ComputedStyle

The computed style of one content node, or of one pseudo-element. An id the tree does not know — an unassigned one, or a node from another book — gets the root style, which is the book’s own defaults.

pub fn notes_area(&self) -> NodeId

The node the footnote area is styled by: the notes element, which stands for the foot of every page.

pub fn paragraph(&self, id: NodeId) -> ParagraphStyle

Everything line layout needs about one node.

pub fn first_letter(&self, id: NodeId) -> Option<&ComputedStyle>

The style ::first-letter computed for one node, when a rule named one. This is where a drop cap’s size and face come from.

pub fn first_line(&self, id: NodeId) -> Option<&ComputedStyle>

The style ::first-line computed for one node, when a rule named one. Line layout reads it as what the opening line changes about the paragraph around it.

pub fn opening_line(&self, id: NodeId) -> Option<FirstLine>

What ::first-line changes about one node’s own style, which is what line layout applies to the opening line.

pub fn before(&self, id: NodeId) -> Option<&ComputedStyle>

The style ::before computed for one node, when its content generates anything. On an inline that is text inside the line. On a block it is a box, the first child of the block.

pub fn after(&self, id: NodeId) -> Option<&ComputedStyle>

The same for ::after.

pub fn pseudo_element( &self, element: NodeId, which: PseudoElement, ) -> Option<NodeId>

The id of one pseudo-element of element, where a rule styles it. On a block, ::before and ::after are boxes. On an inline element, they are text inside the line. The id comes from the element and the pseudo-element alone, so it is the same in every layout of the same book and sheets, and no content node has it. style answers for it.

pub fn counts_pages(&self) -> bool

Whether any generated text prints the page another element lands on. Such a book is laid out twice: once to find the pages, and once to print them.

pub fn refers(&self) -> bool

Whether any generated text names another element, for its page or for its text.

pub fn root(&self) -> &ComputedStyle

The style of the book itself: the root of inheritance.

pub fn styles(&self) -> &[ComputedStyle]

The distinct computed styles, in the order nodes index them.

pub fn nodes(&self) -> &[NodeStyle]

Every element, in document order.

pub fn warnings(&self) -> &[Warning]

What compilation had to complain about.

pub fn page(&self, query: PageQuery<'_>) -> &PageStyle

The page master one page resolves to. A named page with no master of its own falls back to the unnamed one.

pub fn default_page(&self) -> &PageStyle

The default page: an unnamed body recto. The measure every paragraph breaks to comes from here.

pub fn masters(&self) -> &[PageMaster]

Every master this book can put on a page: one per named page and situation, in a stable order.

Trait Implementations

impl Clone for StyleTree

fn clone(&self) -> StyleTree

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StyleTree

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

Formats the value using the given formatter.

impl InlineStyles for StyleTree

fn style(&self, id: NodeId, block: &ParagraphStyle) -> ParagraphStyle

The style of id, given the style of the block it sits in.

fn inline_box(&self, id: NodeId) -> Option<InlineBox>

The box the inline element id paints around its runs, where it paints one. Nothing, for a caller with no tree to ask.

fn generated(&self, _inline: &Inline) -> Generated

The text the sheet generates around one inline element. Nothing, for a caller with no sheet to ask.

fn call(&self, _note: &Inline) -> Option<(String, ParagraphStyle)>

The reference of one note, in the style it is set in: the note’s number as the cascade spells it. Nothing, for a caller with no book to number the notes of.

impl Serialize for StyleTree

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.