Struct HElem

pub struct HElem {
    pub amount: Spacing,
    /* private fields */
}

Inserts horizontal spacing into a paragraph.

The spacing can be absolute, relative, or fractional. In the last case, the remaining space on the line is distributed among all fractional spacings according to their relative fractions.

Example

First #h(1cm) Second \
First #h(30%) Second

Fractional spacing

With fractional spacing, you can align things within a line without forcing a paragraph break (like [align] would). Each fractionally sized element gets space based on the ratio of its fraction to the sum of all fractions.

First #h(1fr) Second \
First #h(1fr) Second #h(1fr) Third \
First #h(2fr) Second #h(1fr) Third

Mathematical Spacing { #math-spacing }

In mathematical formulas, you can additionally use these constants to add spacing between elements: thin (1/6 em), med (2/9 em), thick (5/18 em), quad (1 em), wide (2 em).

Fields

amount: Spacing

Implementations

impl HElem

pub fn new(amount: Spacing) -> Self

Create a new instance of the element.

pub fn with_weak(self, weak: bool) -> Self

Builder-style setter for the weak field.

pub fn push_weak(&mut self, weak: bool)

Setter for the weak field.

pub fn weak(&self, styles: StyleChain<'_>) -> bool

If {true}, the spacing collapses at the start or end of a paragraph. Moreover, from multiple adjacent weak spacings all but the largest one collapse.

Weak spacing in markup also causes all adjacent markup spaces to be removed, regardless of the amount of spacing inserted. To force a space next to weak spacing, you can explicitly write [#" "] (for a normal space) or [~] (for a non-breaking space). The latter can be useful to create a construct that always attaches to the preceding word with one non-breaking space, independently of whether a markup space existed in front or not.

#h(1cm, weak: true)
We identified a group of _weak_
specimens that fail to manifest
in most cases. However, when
#h(8pt, weak: true) supported
#h(8pt, weak: true) on both sides,
they do show up.

Further #h(0pt, weak: true) more,
even the smallest of them swallow
adjacent markup spaces.

pub fn weak_in(styles: StyleChain<'_>) -> bool

Access the weak field in the given style chain.

pub fn set_weak(weak: bool) -> Property

Create a style property for the weak field.

impl HElem

pub fn hole() -> Self

Zero-width horizontal weak spacing that eats surrounding spaces.

Trait Implementations

impl Capable for HElem

fn vtable(capability: TypeId) -> Option<NonNull<()>>

Get the pointer to the vtable for the given capability / trait.

impl Clone for HElem

fn clone(&self) -> HElem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Construct for HElem

fn construct(engine: &mut Engine<'_>, args: &mut Args) -> SourceResult<Content>

Construct an element from the arguments.

impl Debug for HElem

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

Formats the value using the given formatter.

impl Fields for HElem

type Enum = Fields

An enum with the fields of the element.

fn has(&self, id: u8) -> bool

Whether the element has the given field set.

fn field(&self, id: u8) -> Result<Value, FieldAccessError>

Get the field with the given field ID.

fn field_with_styles( &self, id: u8, styles: StyleChain<'_>, ) -> Result<Value, FieldAccessError>

Get the field with the given ID in the presence of styles.

fn field_from_styles( id: u8, styles: StyleChain<'_>, ) -> Result<Value, FieldAccessError>

Get the field with the given ID from the styles.

fn materialize(&mut self, styles: StyleChain<'_>)

Resolve all fields with the styles and save them in-place.

fn fields(&self) -> Dict

Get the fields of the element.

impl Hash for HElem

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 IntoValue for HElem

fn into_value(self) -> Value

Cast this type into a value.

impl NativeElement for HElem

fn data() -> &'static NativeElementData

Get the element data for the native Rust element.

fn elem() -> Element

where Self: Sized,

Get the element for the native Rust element.

fn pack(self) -> Content

where Self: Sized,

Pack the element into type-erased content.

impl PartialEq for HElem

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

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

const 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 Repr for HElem

fn repr(&self) -> EcoString

Return the debug representation of the value.

impl Set for HElem

fn set(engine: &mut Engine<'_>, args: &mut Args) -> SourceResult<Styles>

Parse relevant arguments into style properties for this element.