//! The alternate glyphs of one character as it stands in its text: the glyph the shaper makes for //! it in its word (a medial letter's medial form, not its isolated one), the alternates the font //! gives that glyph, and for each the OpenType feature value that draws it on that character alone //! (`salt=2`, `ss03`). Applying that feature to the character's range swaps the glyph in place //! while the text stays real Unicode and the word is shaped as one piece, so the letters still //! join. Adobe's Glyphs panel does the same for its Show › Alternates for Current Selection: //! use kurbo::Point; use vectorcraft_doc::{CharStyle, TextObject}; use crate::{FontDb, GlyphAlternate, OtFeatures, edit, layout}; /// The most characters on each side of the selected one that are shaped with it: the word it is in. const MAX_WORD: usize = 256; /// The most alternates tried against the text. const MAX_CANDIDATES: usize = 512; /// Does feature `tag` (as a style lists it, with its prefix and value) choose a glyph among a /// glyph's alternates: `aalt`, `salt`, `swsh` or a stylistic set `ss01` to `ss20`? pub fn is_alternate_feature(tag: &str) -> bool { let name = OtFeatures::tag_name(tag); matches!(name, "aalt" | "salt" | "swsh") || (name.len() == 4 && name.starts_with("ss") && OtFeatures::known_tag(name)) } /// The tags to change a character's features by, as `featureChanges` takes them, so that it has /// `tag` as its only feature that chooses an alternate: each such feature of `features` turned /// off, and then `tag` (`salt=2`) when it is given. Empty when the character already has exactly /// that. pub fn alternate_changes(features: &[String], tag: Option<&str>) -> Vec { let mut changes: Vec = vec![]; for t in features.iter().filter(|t| is_alternate_feature(t) && !t.starts_with('-')) { let off = format!("-{}", OtFeatures::tag_name(t)); if tag.is_none_or(|n| OtFeatures::tag_name(n) != OtFeatures::tag_name(t)) && !changes.contains(&off) { changes.push(off); } } if let Some(tag) = tag { let now = OtFeatures::from_tags(features.iter().map(String::as_str)); let wanted = OtFeatures::from_tags([tag]); let name = OtFeatures::tag_name(tag); if now.feature_value(name) != wanted.feature_value(name) { changes.push(tag.to_string()); } } changes } /// One glyph [`alternates_in_context`] lists. #[derive(Clone, Debug, PartialEq, Eq)] pub struct ContextAlternate { pub gid: u32, /// The feature that lists the glyph among the default glyph's alternates (`aalt` first). pub feature: [u8; 4], /// The feature tag that draws the glyph on the character in its word (`salt=2`), when one does. pub apply: Option, } /// What [`alternates_in_context`] finds. #[derive(Clone, Debug, PartialEq, Eq)] pub struct ContextAlternates { /// The face that supplied the glyph ([`crate::PositionedGlyph::font_id`]). pub font_id: u32, /// The glyph the shaper makes for the character with none of its own alternate features: its /// form in its position. pub default: u32, /// The glyph it is drawn with now. pub current: u32, /// The alternates of [`Self::default`] in the font's order (`aalt`, `salt`, `ss01`… as /// [`crate::FontFace::alternates`]), without it unless `aalt` lists it. pub alternates: Vec, } /// The glyph of the layout `text` that draws the character at `byte`, as (face id, glyph id). fn glyph_at(db: &FontDb, text: &TextObject, byte: usize) -> Option<(u32, u32, usize)> { layout(db, text).glyphs.into_iter().find(|g| g.byte <= byte && byte < g.byte.saturating_add(g.len)).map(|g| (g.font_id, g.gid, g.len)) } /// The alternate glyphs of the character at `byte` of `text` as it stands in its word, from the /// glyph the shaper makes for it there, and the feature value that draws each on that character /// alone. The character's own alternate features (`salt`, `ss01`…) are left out when the default /// glyph is found; each alternate's feature is tried on the character in its word, and the one /// that draws that glyph there is its `apply` (`salt` before the stylistic sets, `swsh` and /// `aalt`; a glyph no feature of the font draws in this position has none). `None` when `byte` is /// not a character of the text or the layout holds no glyph for it. Only the word is shaped (up to /// 256 characters each side), so the cost does not grow with the text. pub fn alternates_in_context(db: &FontDb, text: &TextObject, byte: usize) -> Option { let plain = text.plain_text(); let ch = plain.get(byte..)?.chars().next()?; let end = byte + ch.len_utf8(); let breaks = |c: char| c.is_whitespace() || matches!(c, '\u{2028}' | '\u{2029}'); let start = plain[..byte].char_indices().rev().take(MAX_WORD).take_while(|(_, c)| !breaks(*c)).last().map_or(byte, |(i, _)| i); let stop = plain[end..].char_indices().take(MAX_WORD).take_while(|(_, c)| !breaks(*c)).last().map_or(end, |(i, c)| end + i + c.len_utf8()); let mut probe = TextObject::point(Point::ZERO, "", CharStyle::default()); probe.runs = edit::slice_runs(&text.runs, start, stop); probe.vertical = text.vertical; probe.para = text.para.clone(); let (a, b) = (byte - start, end - start); let (_, current, _) = glyph_at(db, &probe, a)?; let own = |probe: &TextObject, tag: Option<&str>| { let mut p = probe.clone(); edit::style_range(&mut p.runs, a, b, |st| { st.glyph_alternate = None; st.features.retain(|t| !is_alternate_feature(t)); st.features.extend(tag.map(str::to_string)); }); glyph_at(db, &p, a) }; let (default_font, default, len) = own(&probe, None)?; let face = db.face_by_id(default_font)?; // A glyph that more than the character makes (a ligature) has no alternates of its own here. let subs = if len == ch.len_utf8() { face.substitutions(default) } else { vec![] }; let mut alternates: Vec = vec![]; let mut tried: Vec<(String, u32)> = vec![]; for sub in &subs { let name = String::from_utf8_lossy(&sub.feature).to_string(); let values = if sub.glyphs.is_empty() { 0 } else { u16::try_from(sub.glyphs.len()).unwrap_or(u16::MAX) }; for value in 1..=values { let tag = if value == 1 { name.clone() } else { format!("{name}={value}") }; if !is_alternate_feature(&tag) || !OtFeatures::known_tag(&tag) || tried.len() >= MAX_CANDIDATES || tried.iter().any(|(t, _)| *t == tag) { continue; } // A single substitution gives its glyph at any value: only the plain tag is tried. if sub.kind == crate::SubstitutionKind::Single && value > 1 { continue; } if let Some((font, gid, _)) = own(&probe, Some(&tag)) && font == default_font { tried.push((tag, gid)); } } } for GlyphAlternate { gid, feature } in crate::fontdb::listed(&subs, default) { let rank = |tag: &str| match OtFeatures::tag_name(tag) { "salt" => 0, "swsh" => 2, "aalt" => 3, _ => 1, }; let mut drawing: Vec<&(String, u32)> = tried.iter().filter(|(_, g)| *g == gid).collect(); drawing.sort_by_key(|(t, _)| rank(t)); alternates.push(ContextAlternate { gid, feature, apply: drawing.first().map(|(t, _)| t.clone()) }); } Some(ContextAlternates { font_id: default_font, default, current, alternates }) }