diff --git a/Cargo.lock b/Cargo.lock index 3e1487dca..877ee914e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1765,6 +1765,7 @@ dependencies = [ "kurbo 0.13.1", "skrifa 0.47.0", "thiserror 2.0.21", + "unicode-bidi", "windows-registry", "write-fonts 0.54.1", ] diff --git a/crates/font-catalog/Cargo.toml b/crates/font-catalog/Cargo.toml index c53d871b8..55b4b1088 100644 --- a/crates/font-catalog/Cargo.toml +++ b/crates/font-catalog/Cargo.toml @@ -19,6 +19,7 @@ harfrust = "0.13" kurbo = { workspace = true } skrifa = { version = "0.47", default-features = false, features = ["std"] } thiserror = { workspace = true } +unicode-bidi = "0.3.18" [target.'cfg(not(target_arch = "wasm32"))'.dependencies] fontique = { version = "0.11.1", default-features = false, features = ["system", "fontconfig-dlopen"], optional = true } diff --git a/crates/font-catalog/src/lib.rs b/crates/font-catalog/src/lib.rs index 21b51ba1a..6489bae5c 100644 --- a/crates/font-catalog/src/lib.rs +++ b/crates/font-catalog/src/lib.rs @@ -31,6 +31,7 @@ mod segments; mod shape; mod suitcase; pub mod system; +mod visual_order; pub use catalog::{Catalog, FontData, FontFileError, Limits, Lister, LoadedFace, Match, Watch}; pub use env::{FontEnv, Os, font_dirs, font_store_dir, office_font_dirs}; @@ -40,6 +41,7 @@ pub use outline::{FontOutline, GlyphPen, OutlineError}; pub use scan::{FaceInfo, LocalizedName, Source, is_font_file, style_italic, style_weight, style_width}; pub use segments::SegmentBoundary; pub use shape::{RunGlyph, RunInput, ShapeRunError, shape_run}; +pub use visual_order::{VisualGlyph, visual_order}; #[cfg(test)] mod tests; diff --git a/crates/font-catalog/src/visual_order.rs b/crates/font-catalog/src/visual_order.rs new file mode 100644 index 000000000..bb753df9a --- /dev/null +++ b/crates/font-catalog/src/visual_order.rs @@ -0,0 +1,69 @@ +//! Visual ordering of shaped clusters after line bidi levels are resolved. +use std::ops::Range; +use unicode_bidi::{BidiInfo, Level}; + +/// A glyph's source byte, source length and original resolved level. +/// Zero-length glyphs represent list markers. +#[derive(Clone, Copy)] +pub struct VisualGlyph { + /// Byte offset in the original text. + pub byte: usize, + /// Source length in bytes, or zero for a list marker. + pub len: usize, + /// Original level, also used when the line levels lack this byte. + pub level: Level, +} + +/// Order glyph indices by cluster using caller-resolved line levels (UAX #9 L1–L2). +/// `levels` is indexed relative to `paragraph_start`. Adjacent marker glyphs at the +/// same byte form their own cluster and reverse internally at a right-to-left level. +pub fn visual_order(glyphs: impl IntoIterator, paragraph_start: usize, levels: &[Level]) -> Vec { + let mut clusters: Vec<(Range, VisualGlyph)> = Vec::new(); + for (i, glyph) in glyphs.into_iter().enumerate() { + if let Some((range, _)) = clusters.last_mut().filter(|(_, prev)| prev.byte == glyph.byte && (prev.len == 0) == (glyph.len == 0)) { + range.end = i + 1; + } else { + clusters.push((i..i + 1, glyph)); + } + } + let cluster_levels: Vec<_> = clusters + .iter() + .map(|(_, g)| if g.len == 0 { g.level } else { levels.get(g.byte.saturating_sub(paragraph_start)).copied().unwrap_or(g.level) }) + .collect(); + BidiInfo::reorder_visual(&cluster_levels) + .into_iter() + .filter_map(|i| clusters.get(i)) + .flat_map(|(range, glyph)| { + let mut indices: Vec<_> = range.clone().collect(); + if glyph.len == 0 && glyph.level.is_rtl() { + indices.reverse(); + } + indices + }) + .collect() +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn clusters_and_markers_keep_their_distinct_order() { + let l = Level::ltr(); + let r = Level::rtl(); + let glyphs = [ + VisualGlyph { byte: 5, len: 0, level: r }, + VisualGlyph { byte: 5, len: 0, level: r }, + VisualGlyph { byte: 5, len: 2, level: r }, + VisualGlyph { byte: 5, len: 2, level: r }, + VisualGlyph { byte: 7, len: 1, level: l }, + ]; + assert_eq!(visual_order(glyphs, 5, &[r, r, l]), vec![2, 3, 1, 0, 4]); + assert!(visual_order([], 0, &[]).is_empty()); + } + #[test] + fn missing_levels_fall_back_to_glyph_level() { + let r = Level::rtl(); + let glyphs = [VisualGlyph { byte: 2, len: 1, level: r }, VisualGlyph { byte: 3, len: 1, level: r }]; + assert_eq!(visual_order(glyphs, 0, &[]), vec![1, 0]); + } +}