Struct FootnoteEntry

pub struct FootnoteEntry {
    pub note: Packed<FootnoteElem>,
    /* private fields */
}

An entry in a footnote list.

This function is not intended to be called directly. Instead, it is used in set and show rules to customize footnote listings.

#show footnote.entry: set text(red)

My footnote listing
#footnote[It's down here]
has red text!

Note: Footnote entry properties must be uniform across each page run (a page run is a sequence of pages without an explicit pagebreak in between). For this reason, set and show rules for footnote entries should be defined before any page content, typically at the very start of the document.

Fields

note: Packed<FootnoteElem>

Implementations

impl FootnoteEntry

pub fn new(note: Packed<FootnoteElem>) -> Self

Create a new instance of the element.

pub fn with_separator(self, separator: Content) -> Self

Builder-style setter for the separator field.

pub fn with_clearance(self, clearance: Length) -> Self

Builder-style setter for the clearance field.

pub fn with_gap(self, gap: Length) -> Self

Builder-style setter for the gap field.

pub fn with_indent(self, indent: Length) -> Self

Builder-style setter for the indent field.

pub fn push_separator(&mut self, separator: Content)

Setter for the separator field.

pub fn push_clearance(&mut self, clearance: Length)

Setter for the clearance field.

pub fn push_gap(&mut self, gap: Length)

Setter for the gap field.

pub fn push_indent(&mut self, indent: Length)

Setter for the indent field.

pub fn separator(&self, styles: StyleChain<'_>) -> Content

The separator between the document body and the footnote listing.

#set footnote.entry(
  separator: repeat[.]
)

Testing a different separator.
#footnote[
  Unconventional, but maybe
  not that bad?
]

pub fn clearance(&self, styles: StyleChain<'_>) -> <Length as Resolve>::Output

The amount of clearance between the document body and the separator.

#set footnote.entry(clearance: 3em)

Footnotes also need ...
#footnote[
  ... some space to breathe.
]

pub fn gap(&self, styles: StyleChain<'_>) -> <Length as Resolve>::Output

The gap between footnote entries.

#set footnote.entry(gap: 0.8em)

Footnotes:
#footnote[Spaced],
#footnote[Apart]

pub fn indent(&self, styles: StyleChain<'_>) -> Length

The indent of each footnote entry.

#set footnote.entry(indent: 0em)

Footnotes:
#footnote[No],
#footnote[Indent]

pub fn separator_in(styles: StyleChain<'_>) -> Content

Access the separator field in the given style chain.

pub fn clearance_in(styles: StyleChain<'_>) -> <Length as Resolve>::Output

Access the clearance field in the given style chain.

pub fn gap_in(styles: StyleChain<'_>) -> <Length as Resolve>::Output

Access the gap field in the given style chain.

pub fn indent_in(styles: StyleChain<'_>) -> Length

Access the indent field in the given style chain.

pub fn set_separator(separator: Content) -> Property

Create a style property for the separator field.

pub fn set_clearance(clearance: Length) -> Property

Create a style property for the clearance field.

pub fn set_gap(gap: Length) -> Property

Create a style property for the gap field.

pub fn set_indent(indent: Length) -> Property

Create a style property for the indent field.

Trait Implementations

impl Capable for FootnoteEntry

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

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

impl Clone for FootnoteEntry

fn clone(&self) -> FootnoteEntry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Construct for FootnoteEntry

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

Construct an element from the arguments.

impl Debug for FootnoteEntry

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

Formats the value using the given formatter.

impl Fields for FootnoteEntry

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 FootnoteEntry

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 FootnoteEntry

fn into_value(self) -> Value

Cast this type into a value.

impl NativeElement for FootnoteEntry

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 FootnoteEntry

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 FootnoteEntry

fn repr(&self) -> EcoString

Return the debug representation of the value.

impl Set for FootnoteEntry

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

Parse relevant arguments into style properties for this element.