Struct Styles 

pub struct Styles(/* private fields */);

A list of style properties.

Implementations

impl Styles

pub const fn new() -> Self

Create a new, empty style list.

pub fn is_empty(&self) -> bool

Whether this contains no styles.

pub fn iter(&self) -> impl Iterator<Item = &Style>

Iterate over the contained styles.

pub fn as_slice(&self) -> &[LazyHash<Style>]

Iterate over the contained styles.

pub fn set<E, const I: u8>(&mut self, field: Field<E, I>, value: E::Type)

where E: SettableProperty<I>, E::Type: Debug + Clone + Hash + Send + Sync + 'static,

Set an inner value for a style property.

If the property needs folding and the value is already contained in the style map, self contributes the outer values and value is the inner one.

pub fn push(&mut self, style: impl Into<Style>)

Add a new style to the list.

pub fn unset(&mut self)

Remove the style that was last set.

pub fn apply(&mut self, outer: Self)

Apply outer styles. Like chain, but in-place.

pub fn apply_one(&mut self, outer: Style)

Apply one outer styles.

pub fn spanned(self, span: Span) -> Self

Add an origin span to all contained properties.

pub fn outside(self) -> Self

Marks the styles as having been applied outside of any show rule.

pub fn liftable(self) -> Self

Marks the styles as being allowed to be lifted up to the page level.

pub fn has<E: NativeElement, const I: u8>(&self, _: Field<E, I>) -> bool

Whether there is a style for the given field of the given element.

pub fn root( children: &[(&Content, StyleChain<'_>)], initial: StyleChain<'_>, ) -> Styles

Determines the styles used for content that it at the root, outside of the user-controlled content (e.g. page marginals and footnotes). This applies to both paged and HTML export.

As a base, we collect the styles that are shared by all elements in the children (this can be a whole document in HTML or a page run in paged export). As a fallback if there are no elements, we use the styles active at the very start or, for page runs, at the pagebreak that introduced the page. Then, to produce our trunk styles, we filter this list of styles according to a few rules:

• Other styles are only kept if they are outside && (initial || liftable).
• “Outside” means they were not produced within a show rule or, for page runs, that the show rule “broke free” to the root level by emitting page styles.
• “Initial” means they were active where the children start (efor pages, at the pagebreak that introduced the page). Since these are intuitively already active, they should be kept even if not liftable. (E.g. text(red, page(..)) makes the footer red.)
• “Liftable” means they can be lifted to the root level even though they weren’t yet active at the very beginning. Set rule styles are liftable as opposed to direct constructor calls:
  • For set page(..); set text(red) the red text is kept even though it comes after the weak pagebreak from set page.
  • For set page(..); text(red)[..] the red isn’t kept because the constructor styles are not liftable.

Trait Implementations

impl Chainable for Styles

fn chain<'a>(&'a self, outer: &'a StyleChain<'_>) -> StyleChain<'a>

Attach self as the first link of the chain.

impl Clone for Styles

fn clone(&self) -> Styles

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Styles

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

Formats the value using the given formatter.

impl Default for Styles

fn default() -> Styles

Returns the “default value” for a type.

impl From<LazyHash<Style>> for Styles

fn from(style: LazyHash<Style>) -> Self

Converts to this type from the input type.

impl From<Style> for Styles

fn from(style: Style) -> Self

Converts to this type from the input type.

impl FromIterator<LazyHash<Style>> for Styles

fn from_iter<T: IntoIterator<Item = LazyHash<Style>>>(iter: T) -> Self

Creates a value from an iterator.

impl FromValue for Styles

fn from_value(value: Value) -> HintedStrResult<Self>

Try to cast the value into an instance of Self.

impl Hash for Styles

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoIterator for Styles

type Item = LazyHash<Style>

The type of the elements being iterated over.

type IntoIter = IntoIter<<Styles as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoValue for Styles

fn into_value(self) -> Value

Cast this type into a value.

impl NativeType for Styles

const NAME: &'static str = "styles"

The type’s name.

fn data() -> &'static NativeTypeData

fn ty() -> Type

Get the type for the native Rust type.

impl PartialEq for Styles

fn eq(&self, other: &Styles) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Reflect for Styles

fn input() -> CastInfo

Describe what can be cast into this value.

fn output() -> CastInfo

Describe what this value can be cast into.

fn castable(value: &Value) -> bool

Whether the given value can be converted to T.

fn error(found: &Value) -> HintedString

Produce an error message for an unacceptable value type.

impl Repr for Styles

fn repr(&self) -> EcoString

Return the debug representation of the value.

impl StructuralPartialEq for Styles