blockworx_text/

rows.rs

//! Breaking a shaped paragraph into rows.
//!
//! The rules are the desktop engine's (epaint's), so a run laid out here
//! breaks where the same run breaks on screen: a row ends at the last
//! whitespace that fits, failing that at a dash or a punctuation mark, and
//! failing that anywhere at all — a word wider than the wrap is broken
//! per character rather than overrun.

use blockworx_geom::{Vec2, WorldPx, vec2};
use blockworx_paint::Font;
use blockworx_paint::text::{Glyph, Layout, Row};

use crate::metrics::Metrics;

/// Stack `paragraphs` — each one a shaped run placed on a single endless row —
/// into the rows that fit `wrap`.
pub(crate) fn rows_of(
    paragraphs: Vec<Vec<Glyph>>,
    wrap: WorldPx,
    metrics: Metrics,
    font: &Font,
) -> Layout {
    let fit = Fit {
        wrap: wrap.get(),
        height: metrics.row_height(font),
    };
    let last = paragraphs.len().saturating_sub(1);
    let mut rows: Vec<Row> = Vec::with_capacity(paragraphs.len());
    for (index, glyphs) in paragraphs.into_iter().enumerate() {
        let ends = if index == last {
            Break::Wrap
        } else {
            Break::Newline
        };
        if glyphs.is_empty() || width_of(&glyphs) <= fit.wrap {
            rows.push(fit.row(glyphs, ends));
            continue;
        }
        fit.break_rows(&glyphs, &mut rows);
        if let Some(row) = rows.last_mut() {
            row.ends_with_newline = ends.closes_a_paragraph();
        }
    }
    stack(rows)
}

/// What a paragraph is broken to fit: the width a row may fill, and the height
/// every row stands whether or not a glyph is on it.
struct Fit {
    wrap: f32,
    height: f32,
}

impl Fit {
    fn break_rows(&self, glyphs: &[Glyph], out: &mut Vec<Row>) {
        let mut candidates = Candidates::default();
        let mut start = 0;
        let mut start_x = 0.0;
        for index in 0..glyphs.len() {
            if self.wrap < right_of(&glyphs[index]) - start_x
                && let Some(kept) = candidates.pick()
            {
                out.push(self.row(shifted(&glyphs[start..=kept], start_x), Break::Wrap));
                // A candidate is only ever recorded for an index already
                // passed, so the row after it is never empty.
                start = kept + 1;
                start_x = glyphs[start].pos.x;
                candidates.forget_before(start);
            }
            candidates.add(index, &glyphs[index..]);
        }
        if start < glyphs.len() {
            out.push(self.row(shifted(&glyphs[start..], start_x), Break::Wrap));
        }
    }

    fn row(&self, glyphs: Vec<Glyph>, ends: Break) -> Row {
        Row {
            pos: Vec2::ZERO,
            height: self.height,
            ends_with_newline: ends.closes_a_paragraph(),
            glyphs,
        }
    }
}

/// What ended a row: the paragraph it closes, or the wrap width it filled.
#[derive(Clone, Copy, PartialEq)]
enum Break {
    Newline,
    Wrap,
}

impl Break {
    fn closes_a_paragraph(self) -> bool {
        self == Break::Newline
    }
}

fn shifted(glyphs: &[Glyph], by: f32) -> Vec<Glyph> {
    glyphs
        .iter()
        .map(|glyph| Glyph {
            pos: vec2(glyph.pos.x - by, glyph.pos.y),
            ..*glyph
        })
        .collect()
}

/// The rows in order, each at its own height below the one before.
fn stack(mut rows: Vec<Row>) -> Layout {
    let mut y = 0.0;
    let mut width: f32 = 0.0;
    for row in &mut rows {
        row.pos = vec2(0.0, y);
        y += row.height;
        width = width.max(width_of(&row.glyphs));
    }
    Layout {
        size: vec2(width, y),
        rows,
    }
}

fn right_of(glyph: &Glyph) -> f32 {
    glyph.pos.x + glyph.advance
}

fn width_of(glyphs: &[Glyph]) -> f32 {
    glyphs.last().map_or(0.0, right_of)
}

/// Where a row could end, best first. The last whitespace is the break a
/// reader expects; the rest are what a word too wide for the wrap falls back
/// through.
#[derive(Default)]
struct Candidates {
    space: Option<usize>,
    cjk: Option<usize>,
    /// Before a CJK character, which may begin a row.
    pre_cjk: Option<usize>,
    dash: Option<usize>,
    punctuation: Option<usize>,
    any: Option<usize>,
}

impl Candidates {
    fn add(&mut self, index: usize, rest: &[Glyph]) {
        const NON_BREAKING_SPACE: char = '\u{A0}';
        let chr = rest[0].chr;
        if chr.is_whitespace() && chr != NON_BREAKING_SPACE {
            self.space = Some(index);
        } else if is_cjk(chr) && (rest.len() == 1 || may_begin_a_row(rest[1].chr)) {
            self.cjk = Some(index);
        } else if chr == '-' {
            self.dash = Some(index);
        } else if chr.is_ascii_punctuation() {
            self.punctuation = Some(index);
        } else if rest.len() > 1 && is_cjk(rest[1].chr) {
            self.pre_cjk = Some(index);
        }
        self.any = Some(index);
    }

    fn pick(&self) -> Option<usize> {
        [self.space, self.cjk, self.pre_cjk]
            .into_iter()
            .max()
            .flatten()
            .or(self.dash)
            .or(self.punctuation)
            .or(self.any)
    }

    fn forget_before(&mut self, index: usize) {
        for candidate in [
            &mut self.space,
            &mut self.cjk,
            &mut self.pre_cjk,
            &mut self.dash,
            &mut self.punctuation,
            &mut self.any,
        ] {
            if candidate.is_some_and(|at| at < index) {
                *candidate = None;
            }
        }
    }
}

/// A logogram or kana — a character that is a word, and so a place a row may
/// end without a space.
fn is_cjk(chr: char) -> bool {
    ('\u{4E00}'..='\u{9FFF}').contains(&chr)
        || ('\u{3400}'..='\u{4DBF}').contains(&chr)
        || ('\u{2B740}'..='\u{2B81F}').contains(&chr)
        || ('\u{3040}'..='\u{309F}').contains(&chr)
        || ('\u{30A0}'..='\u{30FF}').contains(&chr)
}

/// <https://en.wikipedia.org/wiki/Line_breaking_rules_in_East_Asian_languages>
fn may_begin_a_row(chr: char) -> bool {
    !")]｝〕〉》」』】〙〗〟'\"｠»ヽヾーァィゥェォッャュョヮヵヶぁぃぅぇぉっゃゅょゎゕゖㇰㇱㇲㇳㇴㇵㇶㇷㇸㇹㇺㇻㇼㇽㇾㇿ々〻‐゠–〜?!‼⁇⁈⁉・、:;,。."
        .contains(chr)
}