Struct EnumElem

pub struct EnumElem {
    pub children: Vec<Packed<EnumItem>>,
    /* private fields */
}

A numbered list.

Displays a sequence of items vertically and numbers them consecutively.

Example

Automatically numbered:
+ Preparations
+ Analysis
+ Conclusions

Manually numbered:
2. What is the first step?
5. I am confused.
+  Moving on ...

Multiple lines:
+ This enum item has multiple
  lines because the next line
  is indented.

Function call.
#enum[First][Second]

You can easily switch all your enumerations to a different numbering style with a set rule.

#set enum(numbering: "a)")

+ Starting off ...
+ Don't forget step two

You can also use enum.item to programmatically customize the number of each item in the enumeration:

#enum(
  enum.item(1)[First step],
  enum.item(5)[Fifth step],
  enum.item(10)[Tenth step]
)

Syntax

This functions also has dedicated syntax:

• Starting a line with a plus sign creates an automatically numbered enumeration item.
• Starting a line with a number followed by a dot creates an explicitly numbered enumeration item.

Enumeration items can contain multiple paragraphs and other block-level content. All content that is indented more than an item’s marker becomes part of that item.

Fields

children: Vec<Packed<EnumItem>>

Implementations

impl EnumElem

pub fn new(children: Vec<Packed<EnumItem>>) -> EnumElem

Create a new instance of the element.

pub fn with_tight(self, tight: bool) -> EnumElem

Builder-style setter for the tight field.

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

Builder-style setter for the numbering field.

pub fn with_start(self, start: Smart<usize>) -> EnumElem

Builder-style setter for the start field.

pub fn with_full(self, full: bool) -> EnumElem

Builder-style setter for the full field.

pub fn with_reversed(self, reversed: bool) -> EnumElem

Builder-style setter for the reversed field.

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

Builder-style setter for the indent field.

pub fn with_body_indent(self, body_indent: Length) -> EnumElem

Builder-style setter for the body-indent field.

pub fn with_spacing(self, spacing: Smart<Length>) -> EnumElem

Builder-style setter for the spacing field.

pub fn with_number_align(self, number_align: Alignment) -> EnumElem

Builder-style setter for the number-align field.

pub fn push_tight(&mut self, tight: bool)

Setter for the tight field.

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

Setter for the numbering field.

pub fn push_start(&mut self, start: Smart<usize>)

Setter for the start field.

pub fn push_full(&mut self, full: bool)

Setter for the full field.

pub fn push_reversed(&mut self, reversed: bool)

Setter for the reversed field.

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

Setter for the indent field.

pub fn push_body_indent(&mut self, body_indent: Length)

Setter for the body-indent field.

pub fn push_spacing(&mut self, spacing: Smart<Length>)

Setter for the spacing field.

pub fn push_number_align(&mut self, number_align: Alignment)

Setter for the number-align field.

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

Defines the default spacing of the enumeration. If it is {false}, the items are spaced apart with paragraph spacing. If it is {true}, they use paragraph leading instead. This makes the list more compact, which can look better if the items are short.

In markup mode, the value of this parameter is determined based on whether items are separated with a blank line. If items directly follow each other, this is set to {true}; if items are separated by a blank line, this is set to {false}. The markup-defined tightness cannot be overridden with set rules.

+ If an enum has a lot of text, and
  maybe other inline content, it
  should not be tight anymore.

+ To make an enum wide, simply
  insert a blank line between the
  items.

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

How to number the enumeration. Accepts a numbering pattern or function.

If the numbering pattern contains multiple counting symbols, they apply to nested enums. If given a function, the function receives one argument if full is {false} and multiple arguments if full is {true}.

#set enum(numbering: "1.a)")
+ Different
+ Numbering
  + Nested
  + Items
+ Style

#set enum(numbering: n => super[#n])
+ Superscript
+ Numbering!

pub fn start(&self, styles: StyleChain<'_>) -> Smart<usize>

Which number to start the enumeration with.

#enum(
  start: 3,
  [Skipping],
  [Ahead],
)

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

Whether to display the full numbering, including the numbers of all parent enumerations.

#set enum(numbering: "1.a)", full: true)
+ Cook
  + Heat water
  + Add ingredients
+ Eat

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

Whether to reverse the numbering for this enumeration.

#set enum(reversed: true)
+ Coffee
+ Tea
+ Milk

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

The indentation of each item.

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

The space between the numbering and the body of each item.

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

The spacing between the items of the enumeration.

If set to {auto}, uses paragraph leading for tight enumerations and paragraph spacing for wide (non-tight) enumerations.

pub fn number_align(&self, styles: StyleChain<'_>) -> Alignment

The alignment that enum numbers should have.

By default, this is set to {end + top}, which aligns enum numbers towards end of the current text direction (in left-to-right script, for example, this is the same as {right}) and at the top of the line. The choice of {end} for horizontal alignment of enum numbers is usually preferred over {start}, as numbers then grow away from the text instead of towards it, avoiding certain visual issues. This option lets you override this behaviour, however. (Also to note is that the unordered list uses a different method for this, by giving the marker content an alignment directly.).

#set enum(number-align: start + bottom)

Here are some powers of two:
1. One
2. Two
4. Four
8. Eight
16. Sixteen
32. Thirty two

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

Access the tight field in the given style chain.

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

Access the numbering field in the given style chain.

pub fn start_in(styles: StyleChain<'_>) -> Smart<usize>

Access the start field in the given style chain.

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

Access the full field in the given style chain.

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

Access the reversed field in the given style chain.

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

Access the indent field in the given style chain.

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

Access the body-indent field in the given style chain.

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

Access the spacing field in the given style chain.

pub fn number_align_in(styles: StyleChain<'_>) -> Alignment

Access the number-align field in the given style chain.

pub fn parents_in(styles: StyleChain<'_>) -> SmallVec<[usize; 4]>

Access the parents field in the given style chain.

pub fn set_tight(tight: bool) -> Property

Create a style property for the tight field.

pub fn set_numbering(numbering: Numbering) -> Property

Create a style property for the numbering field.

pub fn set_start(start: Smart<usize>) -> Property

Create a style property for the start field.

pub fn set_full(full: bool) -> Property

Create a style property for the full field.

pub fn set_reversed(reversed: bool) -> Property

Create a style property for the reversed field.

pub fn set_indent(indent: Length) -> Property

Create a style property for the indent field.

pub fn set_body_indent(body_indent: Length) -> Property

Create a style property for the body-indent field.

pub fn set_spacing(spacing: Smart<Length>) -> Property

Create a style property for the spacing field.

pub fn set_number_align(number_align: Alignment) -> Property

Create a style property for the number-align field.

pub fn set_parents(parents: SmallVec<[usize; 4]>) -> Property

Create a style property for the parents field.

Trait Implementations

impl Capable for EnumElem

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

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

impl Clone for EnumElem

fn clone(&self) -> EnumElem

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Construct for EnumElem

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

Construct an element from the arguments.

impl Debug for EnumElem

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

Formats the value using the given formatter.

impl Fields for EnumElem

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 EnumElem

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 EnumElem

fn into_value(self) -> Value

Cast this type into a value.

impl ListLike for EnumElem

type Item = EnumItem

The kind of list item this list is composed of.

fn create( children: Vec<Packed<<EnumElem as ListLike>::Item>>, tight: bool, ) -> EnumElem

Create this kind of list from its children and tightness.

impl NativeElement for EnumElem

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 EnumElem

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 EnumElem

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

fn repr(&self) -> EcoString

Return the debug representation of the value.

impl Set for EnumElem

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

Parse relevant arguments into style properties for this element.