Struct TextLayout 

pub struct TextLayout {
    pub text: String,
    pub content_widths: Option<CachedContentWidths>,
    pub layout: Layout<TextBrush>,
    pub laid_out_at: Option<f32>,
}

Fields

text: String

content_widths: Option<CachedContentWidths>

layout: Layout<TextBrush>

laid_out_at: Option<f32>

The width the lines were last broken at by a layout pass, in device pixels.

Measuring re-breaks the same layout at trial widths and stores the result back on the node, so the state left behind belongs to whichever pass ran last, and that is often a max-content measurement rather than the layout. Non-atomic inline elements read their geometry straight out of this layout, so they then report boxes from a line that is not on screen: measured on a live transcript as a block 713px wide and three lines tall sitting over a single line 1,742px wide, with its <code> and <strong> boxes up to 987px outside the pane.

Recording it lets a measuring pass put the lines back where layout left them.

Implementations

impl TextLayout

pub fn new() -> Self

pub fn content_widths(&mut self) -> ContentWidths

The layout’s min-content and max-content widths, recomputed only when the inputs to that computation have actually changed.

WHY this is cached: Layout::calculate_content_widths walks every shaped cluster in the layout, and block layout asks for the content widths two or three times per pass (once under a min-content constraint, once under max-content, then again for the definite measure), so the same scan is repeated over the same data.

WHY it is safe: the result is a pure function of exactly two things, the shaped runs and the current width of each inline box.

The shaped runs only change when the inline layout is rebuilt, and every rebuild goes through build_inline_layout_into, which clears this cache. Damage propagation clears it too, in the same places it clears the Taffy layout cache, so a text edit or a style change affecting font, size, weight, letter/word spacing or white-space collapsing always re-measures.

The inline box widths are the reason this cannot be a plain one-shot cache: they are re-measured on every pass, and an inline box legitimately measures differently under a min-content constraint than under a max-content one, so the same shaped text can yield different content widths from one call to the next. Rather than guess which constraint a cached entry belongs to, we record the box widths the entry was computed from and reuse it only when they are bit-for-bit identical. A layout containing no inline boxes, which is the common case and where the scan cost is concentrated, therefore hits the cache on every pass after the first.

Trait Implementations

impl Clone for TextLayout

fn clone(&self) -> TextLayout

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TextLayout

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

Formats the value using the given formatter.

impl Default for TextLayout

fn default() -> TextLayout

Returns the “default value” for a type.