use super::font::CaptionFont;
use crate::loaders::shape;
use super::{bidi, compose};
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Placed {
pub gid: u32,
pub cluster: usize,
pub attach: Option<(usize, f32, f32)>,
pub rtl: bool,
}
pub fn visual(text: &str, font: &CaptionFont, size: f32) -> Vec<Placed> {
let typed: Vec<char> = text.chars().collect();
let mut chars = compose::composed(&typed);
if chars.is_empty() {
return Vec::new();
}
let classes: Vec<bidi::Class> = chars.iter().map(|c| bidi::class(*c)).collect();
let levels = bidi::resolve_classes(&classes, bidi::Direction::Auto);
for (i, c) in chars.iter_mut().enumerate() {
*c = bidi::mirror::at_level(*c, levels.levels.get(i).copied().unwrap_or(0));
}
let scripts = shape::script::runs(&chars);
let mut runs: Vec<(usize, usize, u8, [u8; 4])> = Vec::new();
for i in 0..chars.len() {
let level = levels.levels.get(i).copied().unwrap_or(0);
let script = scripts
.iter()
.find(|(a, b, _)| i >= *a && i < *b)
.map_or(shape::script::DEFAULT, |(_, _, t)| *t);
match runs.last_mut() {
Some((_, end, l, s)) if *l == level && *s == script && *end == i => *end = i + 1,
_ => runs.push((i, i + 1, level, script)),
}
}
let mut shaped: Vec<Vec<Placed>> = Vec::with_capacity(runs.len());
for (a, b, level, script) in &runs {
let rtl = level % 2 == 1;
let ids = font.shape_run(&chars[*a..*b], script, size);
let marks = font.attachments(&ids.iter().map(|(g, _)| *g).collect::<Vec<_>>(), size);
let mut run: Vec<Placed> = ids
.into_iter()
.zip(marks)
.map(|((gid, cluster), m)| Placed {
gid,
cluster: a + cluster,
attach: m.to.map(|t| (usize::from(t), m.dx, m.dy)),
rtl,
})
.collect();
if rtl {
let n = run.len();
for p in &mut run {
p.attach = p.attach.map(|(t, dx, dy)| (n - 1 - t, dx, dy));
}
run.reverse();
}
shaped.push(run);
}
let run_levels: Vec<u8> = runs.iter().map(|(_, _, l, _)| *l).collect();
let mut out: Vec<Placed> = Vec::new();
for i in bidi::reorder(&run_levels, levels.paragraph) {
let Some(run) = shaped.get(i) else { continue };
let base = out.len();
out.extend(run.iter().map(|p| Placed {
attach: p.attach.map(|(t, dx, dy)| (base + t, dx, dy)),
..*p
}));
}
out
}
pub fn pair(previous: Placed, current: Placed) -> (u32, u32) {
if previous.rtl && current.rtl {
(current.gid, previous.gid)
} else {
(previous.gid, current.gid)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn face() -> CaptionFont {
CaptionFont::builtin()
}
fn text(s: &str) -> String {
visual(s, &face(), 16.0)
.into_iter()
.filter_map(|p| char::from_u32(p.gid))
.collect()
}
#[test]
fn latin_is_left_alone() {
assert_eq!(text("Hello, world"), "Hello, world");
assert_eq!(text(""), "");
}
#[test]
fn an_accent_composes() {
assert_eq!(text("Noe\u{0308}l"), "Noël");
}
#[test]
fn hebrew_is_reversed() {
let typed: Vec<char> = "אבגד".chars().collect();
let drawn: Vec<char> = text("אבגד").chars().collect();
assert_eq!(drawn, typed.iter().rev().copied().collect::<Vec<_>>());
assert!(visual("אבגד", &face(), 16.0).iter().all(|p| p.rtl));
}
#[test]
fn a_number_after_hebrew_stays_in_order() {
assert_eq!(text("א123ב"), "ב123א");
}
#[test]
fn latin_inside_hebrew_keeps_its_direction() {
assert_eq!(text("אabcב"), "בabcא");
}
#[test]
fn a_bracket_mirrors_in_a_right_to_left_run() {
assert_eq!(text("א(ב)ג"), "ג(ב)א");
}
#[test]
fn a_kerning_pair_is_logical() {
let f = face();
let run = visual("אב", &f, 16.0);
assert_eq!(
pair(run[0], run[1]),
('א' as u32, 'ב' as u32),
"an RTL pair was taken visually"
);
let latin = visual("AV", &f, 16.0);
assert_eq!(pair(latin[0], latin[1]), ('A' as u32, 'V' as u32));
}
#[test]
fn a_cluster_points_back_at_the_composed_text() {
let run = visual("Noe\u{0308}l", &face(), 16.0);
assert_eq!(run.len(), 4);
assert_eq!(run[3].cluster, 3);
assert_eq!(char::from_u32(run[3].gid), Some('l'));
}
#[test]
fn a_right_to_left_run_keeps_its_clusters_with_its_glyphs() {
let run = visual("אבג", &face(), 16.0);
let clusters: Vec<usize> = run.iter().map(|p| p.cluster).collect();
assert_eq!(clusters, vec![2, 1, 0]);
}
}