Struct PlaceElem 

pub struct PlaceElem {
    pub alignment: Settable<Self, 0u8>,
    pub scope: Settable<Self, 1u8>,
    pub float: Settable<Self, 2u8>,
    pub clearance: Settable<Self, 3u8>,
    pub dx: Settable<Self, 4u8>,
    pub dy: Settable<Self, 5u8>,
    pub body: Content,
}

Places content relatively to its parent container.

Placed content can be either overlaid (the default) or floating. Overlaid content is aligned with the parent container according to the given alignment, and shown over any other content added so far in the container. Floating content is placed at the top or bottom of the container, displacing other content down or up respectively. In both cases, the content position can be adjusted with dx and dy offsets without affecting the layout.

The parent can be any container such as a [block], [box], [rect], etc. A top level place call will place content directly in the text area of the current page. This can be used for absolute positioning on the page: with a top + left alignment, the offsets dx and dy will set the position of the element’s top left corner relatively to the top left corner of the text area. For absolute positioning on the full page including margins, you can use place in [page.foreground] or [page.background].

Examples

#set page(height: 120pt)
Hello, world!

#rect(
  width: 100%,
  height: 2cm,
  place(horizon + right, square()),
)

#place(
  top + left,
  dx: -5pt,
  square(size: 5pt, fill: red),
)

Effect on the position of other elements { #effect-on-other-elements }

Overlaid elements don’t take space in the flow of content, but a place call inserts an invisible block-level element in the flow. This can affect the layout by breaking the current paragraph. To avoid this, you can wrap the place call in a [box] when the call is made in the middle of a paragraph. The alignment and offsets will then be relative to this zero-size box. To make sure it doesn’t interfere with spacing, the box should be attached to a word using a word joiner.

For example, the following defines a function for attaching an annotation to the following word:

>>> #set page(height: 70pt)
#let annotate(..args) = {
  box(place(..args))
  sym.wj
  h(0pt, weak: true)
}

A placed #annotate(square(), dy: 2pt)
square in my text.

The zero-width weak spacing serves to discard spaces between the function call and the next word.

Accessibility

Assistive Technology (AT) will always read the placed element at the point where it logically appears in the document, regardless of where this function physically moved it. Put its markup where it would make the most sense in the reading order.

Fields

alignment: Settable<Self, 0u8>

scope: Settable<Self, 1u8>

float: Settable<Self, 2u8>

clearance: Settable<Self, 3u8>

dx: Settable<Self, 4u8>

dy: Settable<Self, 5u8>

body: Content

Implementations

impl PlaceElem

pub fn new(body: Content) -> Self

Create a new instance of the element.

pub fn with_alignment(self, alignment: Smart<Alignment>) -> Self

Builder-style setter for the alignment field.

pub fn with_scope(self, scope: PlacementScope) -> Self

Builder-style setter for the scope field.

pub fn with_float(self, float: bool) -> Self

Builder-style setter for the float field.

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

Builder-style setter for the clearance field.

pub fn with_dx(self, dx: Rel<Length>) -> Self

Builder-style setter for the dx field.

pub fn with_dy(self, dy: Rel<Length>) -> Self

Builder-style setter for the dy field.

impl PlaceElem

pub const alignment: Field<Self, 0u8>

pub const scope: Field<Self, 1u8>

pub const float: Field<Self, 2u8>

pub const clearance: Field<Self, 3u8>

pub const dx: Field<Self, 4u8>

pub const dy: Field<Self, 5u8>

pub const body: Field<Self, 6u8>

Trait Implementations

impl Clone for PlaceElem

fn clone(&self) -> PlaceElem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Construct for PlaceElem

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

Construct an element from the arguments.

impl Debug for PlaceElem

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

Formats the value using the given formatter.

impl Hash for PlaceElem

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 PlaceElem

const ELEM: Element

The associated element.

fn pack(self) -> Content

Pack the element into type-erased content.

impl NativeScope for PlaceElem

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

The constructor function for the type, if any.

fn scope() -> Scope

Get the associated scope for the type.

impl RequiredField<6> for PlaceElem

const FIELD: RequiredFieldData<Self, 6u8>

type Type = Content

impl Set for PlaceElem

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

Parse relevant arguments into style properties for this element.

impl SettableField<0> for PlaceElem

const FIELD: SettableFieldData<Self, 0u8>

type Type = Smart<Alignment>

impl SettableField<1> for PlaceElem

const FIELD: SettableFieldData<Self, 1u8>

type Type = PlacementScope

impl SettableField<2> for PlaceElem

const FIELD: SettableFieldData<Self, 2u8>

type Type = bool

impl SettableField<3> for PlaceElem

const FIELD: SettableFieldData<Self, 3u8>

type Type = Length

impl SettableField<4> for PlaceElem

const FIELD: SettableFieldData<Self, 4u8>

type Type = Rel

impl SettableField<5> for PlaceElem

const FIELD: SettableFieldData<Self, 5u8>

type Type = Rel

impl RefableProperty<0> for PlaceElem

impl RefableProperty<1> for PlaceElem

impl RefableProperty<2> for PlaceElem

impl RefableProperty<3> for PlaceElem

impl RefableProperty<4> for PlaceElem

impl RefableProperty<5> for PlaceElem