Struct Line 

pub struct Line {
    pub glyph_start: usize,
    pub glyph_end: usize,
    pub metrics: LineMetrics,
}

A single laid-out line: a contiguous slice of positioned glyphs plus its metrics.

Fields

glyph_start: usize

Index of the first glyph of this line in LayoutResult::glyphs.

glyph_end: usize

Index past the last glyph of this line in LayoutResult::glyphs.

metrics: LineMetrics

Vertical and width metrics for the line.

Implementations

impl Line

pub fn len(&self) -> usize

Number of glyphs in the line.

Examples found in repository

examples/word_aware_layout.rs (line 86)

fn main() {
    let text = "The quick brown fox jumps";
    let run = shaped_run_from_text(text, 12.0);

    // Wrap at 120px — narrow enough that the paragraph spans several lines.
    let constraints = LayoutConstraints {
        max_width: 120.0,
        font_size: 16.0,
    };

    let mut engine = LayoutEngine::new();
    let result = engine
        .layout(text, &[run], &constraints, TextAlignment::Left, None)
        .expect("layout is currently infallible for well-formed input");

    println!(
        "laid out {} glyph(s) into {} line(s); paragraph size = {:.1} x {:.1}px",
        result.glyphs.len(),
        result.lines.len(),
        result.metrics.total_width,
        result.metrics.total_height,
    );
    assert!(
        result.lines.len() > 1,
        "narrow max_width should force wraps"
    );

    for (i, line) in result.lines.iter().enumerate() {
        let glyphs = &result.glyphs[line.glyph_start..line.glyph_end];
        let first_x = glyphs.first().map(|g| g.pos.0).unwrap_or(0.0);
        println!(
            "  line {i}: {} glyph(s), starts at x={first_x:.1}, width={:.1}px",
            line.len(),
            line.metrics.width,
        );
        // Every wrapped line must restart at the left edge.
        assert!((first_x - 0.0).abs() < 1e-3);
    }

    // Hand-off to a rasterizer / SDF atlas: the unique (glyph_id, px_size)
    // pairs actually used by this layout, in first-occurrence order.
    let glyph_set = result.unique_glyphs_for_atlas();
    println!(
        "{} unique glyph(s) needed for rasterization",
        glyph_set.len()
    );
    assert!(!glyph_set.is_empty());
}

pub fn is_empty(&self) -> bool

Returns true if the line has no glyphs.

Trait Implementations

impl Clone for Line

fn clone(&self) -> Line

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Line

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

Formats the value using the given formatter.