Struct OutlineElem 

pub struct OutlineElem {
    pub title: Settable<Self, 0u8>,
    pub target: Settable<Self, 1u8>,
    pub depth: Settable<Self, 2u8>,
    pub indent: Settable<Self, 3u8>,
}

A table of contents, figures, or other elements.

This function generates a list of all occurrences of an element in the document, up to a given depth. The element’s numbering and page number will be displayed in the outline alongside its title or caption.

Example

#set heading(numbering: "1.")
#outline()

= Introduction
#lorem(5)

= Methods
== Setup
#lorem(10)

Alternative outlines

In its default configuration, this function generates a table of contents. By setting the target parameter, the outline can be used to generate a list of other kinds of elements than headings.

In the example below, we list all figures containing images by setting target to {figure.where(kind: image)}. Just the same, we could have set it to {figure.where(kind: table)} to generate a list of tables.

We could also set it to just figure, without using a where selector, but then the list would contain all figures, be it ones containing images, tables, or other material.

#outline(
  title: [List of Figures],
  target: figure.where(kind: image),
)

#figure(
  image("tiger.jpg"),
  caption: [A nice figure!],
)

Styling the outline

At the most basic level, you can style the outline by setting properties on it and its entries. This way, you can customize the outline’s title, how outline entries are indented, and how the space between an entry’s text and its page number should be filled.

Richer customization is possible through configuration of the outline’s entries. The outline generates one entry for each outlined element.

Spacing the entries { #entry-spacing }

Outline entries are blocks, so you can adjust the spacing between them with normal block-spacing rules:

#show outline.entry.where(
  level: 1
): set block(above: 1.2em)

#outline()

= About ACME Corp.
== History
=== Origins
= Products
== ACME Tools

Building an outline entry from its parts { #building-an-entry }

For full control, you can also write a transformational show rule on outline.entry. However, the logic for properly formatting and indenting outline entries is quite complex and the outline entry itself only contains two fields: The level and the outlined element.

For this reason, various helper functions are provided. You can mix and match these to compose an entry from just the parts you like.

The default show rule for an outline entry looks like this¹:

#show outline.entry: it => link(
  it.element.location(),
  it.indented(it.prefix(), it.inner()),
)

• The indented function takes an optional prefix and inner content and automatically applies the proper indentation to it, such that different entries align nicely and long headings wrap properly.

• The prefix function formats the element’s numbering (if any). It also appends a supplement for certain elements.

• The inner function combines the element’s body, the filler, and the page number.

You can use these individual functions to format the outline entry in different ways. Let’s say, you’d like to fully remove the filler and page numbers. To achieve this, you could write a show rule like this:

#show outline.entry: it => link(
  it.element.location(),
  // Keep just the body, dropping
  // the fill and the page.
  it.indented(it.prefix(), it.body()),
)

#outline()

= About ACME Corp.
== History

---

1. The outline of equations is the exception to this rule as it does not have a body and thus does not use indented layout. ↩

Fields

title: Settable<Self, 0u8>

target: Settable<Self, 1u8>

depth: Settable<Self, 2u8>

indent: Settable<Self, 3u8>

Implementations

impl OutlineElem

pub fn new() -> Self

Create a new instance of the element.

pub fn with_title(self, title: Smart<Option<Content>>) -> Self

Builder-style setter for the title field.

pub fn with_target(self, target: LocatableSelector) -> Self

Builder-style setter for the target field.

pub fn with_depth(self, depth: Option<NonZeroUsize>) -> Self

Builder-style setter for the depth field.

pub fn with_indent(self, indent: Smart<OutlineIndent>) -> Self

Builder-style setter for the indent field.

impl OutlineElem

pub const title: Field<Self, 0u8>

pub const target: Field<Self, 1u8>

pub const depth: Field<Self, 2u8>

pub const indent: Field<Self, 3u8>

Trait Implementations

impl Clone for OutlineElem

fn clone(&self) -> OutlineElem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Construct for OutlineElem

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

Construct an element from the arguments.

impl Debug for OutlineElem

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

Formats the value using the given formatter.

impl Hash for OutlineElem

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 NativeElement for OutlineElem

const ELEM: Element

The associated element.

fn pack(self) -> Content

Pack the element into type-erased content.

impl NativeScope for OutlineElem

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

The constructor function for the type, if any.

fn scope() -> Scope

Get the associated scope for the type.

impl Set for OutlineElem

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

Parse relevant arguments into style properties for this element.

impl SettableField<0> for OutlineElem

const FIELD: SettableFieldData<Self, 0u8>

type Type = Smart<Option<Content>>

impl SettableField<1> for OutlineElem

const FIELD: SettableFieldData<Self, 1u8>

type Type = LocatableSelector

impl SettableField<2> for OutlineElem

const FIELD: SettableFieldData<Self, 2u8>

type Type = Option<NonZero<usize>>

impl SettableField<3> for OutlineElem

const FIELD: SettableFieldData<Self, 3u8>

type Type = Smart<OutlineIndent>

impl RefableProperty<0> for OutlineElem

impl RefableProperty<1> for OutlineElem

impl RefableProperty<2> for OutlineElem

impl RefableProperty<3> for OutlineElem