Struct Tiling

pub struct Tiling(/* private fields */);

A repeating tiling fill.

Typst supports the most common type of tilings, where a pattern is repeated in a grid-like fashion, covering the entire area of an element that is filled or stroked. The pattern is defined by a tile size and a body defining the content of each cell. You can also add horizontal or vertical spacing between the cells of the tiling.

Examples

#let pat = tiling(size: (30pt, 30pt))[
  #place(line(start: (0%, 0%), end: (100%, 100%)))
  #place(line(start: (0%, 100%), end: (100%, 0%)))
]

#rect(fill: pat, width: 100%, height: 60pt, stroke: 1pt)

Tilings are also supported on text, but only when setting the relativeness to either {auto} (the default value) or {"parent"}. To create word-by-word or glyph-by-glyph tilings, you can wrap the words or characters of your text in boxes manually or through a show rule.

#let pat = tiling(
  size: (30pt, 30pt),
  relative: "parent",
  square(
    size: 30pt,
    fill: gradient
      .conic(..color.map.rainbow),
  )
)

#set text(fill: pat)
#lorem(10)

You can also space the elements further or closer apart using the spacing feature of the tiling. If the spacing is lower than the size of the tiling, the tiling will overlap. If it is higher, the tiling will have gaps of the same color as the background of the tiling.

#let pat = tiling(
  size: (30pt, 30pt),
  spacing: (10pt, 10pt),
  relative: "parent",
  square(
    size: 30pt,
    fill: gradient
     .conic(..color.map.rainbow),
  ),
)

#rect(
  width: 100%,
  height: 60pt,
  fill: pat,
)

Relativeness

The location of the starting point of the tiling is dependent on the dimensions of a container. This container can either be the shape that it is being painted on, or the closest surrounding container. This is controlled by the relative argument of a tiling constructor. By default, tilings are relative to the shape they are being painted on, unless the tiling is applied on text, in which case they are relative to the closest ancestor container.

Typst determines the ancestor container as follows:

• For shapes that are placed at the root/top level of the document, the closest ancestor is the page itself.
• For other shapes, the ancestor is the innermost [block] or [box] that contains the shape. This includes the boxes and blocks that are implicitly created by show rules and elements. For example, a [rotate] will not affect the parent of a gradient, but a [grid] will.

Compatibility

This type used to be called pattern. The name remains as an alias, but is deprecated since Typst 0.13.

Implementations

impl Tiling

pub fn construct( engine: &mut Engine<'_>, span: Span, size: Spanned<Smart<Axes<Length>>>, spacing: Spanned<Axes<Length>>, relative: Smart<RelativeTo>, body: Content, ) -> SourceResult<Tiling>

Construct a new tiling.

#let pat = tiling(
  size: (20pt, 20pt),
  relative: "parent",
  place(
    dx: 5pt,
    dy: 5pt,
    rotate(45deg, square(
      size: 5pt,
      fill: black,
    )),
  ),
)

#rect(width: 100%, height: 60pt, fill: pat)

impl Tiling

pub fn with_relative(self, relative: RelativeTo) -> Self

Set the relative placement of the tiling.

pub fn frame(&self) -> &Frame

Return the frame of the tiling.

pub fn size(&self) -> Size

Return the size of the tiling in absolute units.

pub fn spacing(&self) -> Size

Return the spacing of the tiling in absolute units.

pub fn relative(&self) -> Smart<RelativeTo>

Returns the relative placement of the tiling.

pub fn unwrap_relative(&self, on_text: bool) -> RelativeTo

Returns the relative placement of the tiling.

Trait Implementations

impl Clone for Tiling

fn clone(&self) -> Tiling

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Tiling

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

Formats the value using the given formatter.

impl From<Tiling> for Paint

fn from(tiling: Tiling) -> Self

Converts to this type from the input type.

impl FromValue for Tiling

fn from_value(value: Value) -> HintedStrResult<Self>

Try to cast the value into an instance of Self.

impl Hash for Tiling

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 Tiling

fn into_value(self) -> Value

Cast this type into a value.

impl NativeScope for Tiling

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

The constructor function for the type, if any.

fn scope() -> Scope

Get the associated scope for the type.

impl NativeType for Tiling

const NAME: &'static str = "tiling"

The type’s name.

fn data() -> &'static NativeTypeData

fn ty() -> Type

Get the type for the native Rust type.

impl PartialEq for Tiling

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

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 Tiling

fn repr(&self) -> EcoString

Return the debug representation of the value.

impl Eq for Tiling

impl StructuralPartialEq for Tiling