Struct FootnoteElem

pub struct FootnoteElem {
    pub body: FootnoteBody,
    /* private fields */
}

A footnote.

Includes additional remarks and references on the same page with footnotes. A footnote will insert a superscript number that links to the note at the bottom of the page. Notes are numbered sequentially throughout your document and can break across multiple pages.

To customize the appearance of the entry in the footnote listing, see footnote.entry. The footnote itself is realized as a normal superscript, so you can use a set rule on the super function to customize it. You can also apply a show rule to customize only the footnote marker (superscript number) in the running text.

Example

Check the docs for more details.
#footnote[https://typst.app/docs]

The footnote automatically attaches itself to the preceding word, even if there is a space before it in the markup. To force space, you can use the string [#" "] or explicit horizontal spacing.

By giving a label to a footnote, you can have multiple references to it.

You can edit Typst documents online.
#footnote[https://typst.app/app] <fn>
Checkout Typst's website. @fn
And the online app. #footnote(<fn>)

Note: Set and show rules in the scope where footnote is called may not apply to the footnote’s content. See here for more information.

Fields

body: FootnoteBody

Implementations

impl FootnoteElem

pub fn new(body: FootnoteBody) -> FootnoteElem

Create a new instance of the element.

pub fn with_numbering(self, numbering: Numbering) -> FootnoteElem

Builder-style setter for the numbering field.

pub fn push_numbering(&mut self, numbering: Numbering)

Setter for the numbering field.

pub fn numbering<'a>(&'a self, styles: StyleChain<'a>) -> &'a Numbering

How to number footnotes.

By default, the footnote numbering continues throughout your document. If you prefer per-page footnote numbering, you can reset the footnote [counter] in the page header. In the future, there might be a simpler way to achieve this.

#set footnote(numbering: "*")

Footnotes:
#footnote[Star],
#footnote[Dagger]

pub fn numbering_in(styles: StyleChain<'_>) -> &Numbering

Access the numbering field in the given style chain.

pub fn set_numbering(numbering: Numbering) -> Property

Create a style property for the numbering field.

impl FootnoteElem

pub fn with_content(content: Content) -> FootnoteElem

Creates a new footnote that the passed content as its body.

pub fn with_label(label: Label) -> FootnoteElem

Creates a new footnote referencing the footnote with the specified label.

pub fn into_ref(&self, label: Label) -> FootnoteElem

Creates a new footnote referencing the footnote with the specified label, with the other fields from the current footnote cloned.

pub fn is_ref(&self) -> bool

Tests if this footnote is a reference to another footnote.

pub fn body_content(&self) -> Option<&Content>

Returns the content of the body of this footnote if it is not a ref.

Trait Implementations

impl Capable for FootnoteElem

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

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

impl Clone for FootnoteElem

fn clone(&self) -> FootnoteElem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Construct for FootnoteElem

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

Construct an element from the arguments.

impl Debug for FootnoteElem

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

Formats the value using the given formatter.

impl Fields for FootnoteElem

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 FromValue for FootnoteElem

fn from_value(value: Value) -> Result<FootnoteElem, HintedString>

Try to cast the value into an instance of Self.

impl Hash for FootnoteElem

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

where __H: Hasher,

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 FootnoteElem

fn into_value(self) -> Value

Cast this type into a value.

impl NativeElement for FootnoteElem

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 NativeScope for FootnoteElem

fn constructor() -> Option<&'static NativeFuncData>

The constructor function for the type, if any.

fn scope() -> Scope

Get the associated scope for the type.

impl PartialEq for FootnoteElem

fn eq(&self, other: &FootnoteElem) -> 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 Reflect for FootnoteElem

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 FootnoteElem

fn repr(&self) -> EcoString

Return the debug representation of the value.

impl Set for FootnoteElem

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

Parse relevant arguments into style properties for this element.