Skip to main content

text/
shaping.rs

1//! Opt-in complex text layout. UI controls keep their existing metrics unless enabled.
2use alloc::{vec::Vec, string::String};
3use crate::{Text, registry::Face};
4
5#[derive(Default)]
6pub(crate) struct Cache {
7    pub enabled: bool, serial: u64, font: u32, size: i32,
8    engine: Option<text_shape::Engine>, text: String, glyphs: Vec<Placed>, carets: Vec<(usize,i32)>, width: i32,
9    fallbacks: Vec<(u32, text_shape::Engine)>,
10    segments: Vec<(usize, usize, i32, i32)>,
11}
12#[derive(Clone, Copy)]
13pub(crate) struct Placed { pub font: u32, pub id: u32, pub x: i32, pub y: i32 }
14impl Text {
15    /// Enable OpenType shaping for measure, draw, hit testing and carets. Returns
16    /// the previous state so callers can scope this to a document's text tool.
17    pub fn set_shaping(&mut self, enabled: bool) -> bool { core::mem::replace(&mut self.shaping.enabled,enabled) }
18    // (fallback.rs) the line shaped last is shaped again: the fonts for its missing characters changed
19    pub(crate) fn shaping_forget(&mut self) { self.shaping.size=0; }
20    pub fn set_fallback_fonts(&mut self, fonts: &[u32]) {
21        if self.fb.app != fonts { self.fallback_app(fonts); }
22        let ids:Vec<_>=self.shaping.fallbacks.iter().map(|v|v.0).collect();
23        if ids==fonts { return; }
24        self.shaping.fallbacks=fonts.iter().take(16).filter_map(|&id| self.shape_engine(id).map(|e|(id,e))).collect();
25        self.shaping.size=0;
26    }
27    fn shape_face(&self, mut font: u32) -> Option<&crate::ttf::TtFont> {
28        for _ in 0..16 { match self.face(font)? { Face::Tt(tt) => return Some(tt), Face::Syn(s) => font=s.base, Face::Var(v) => font=v.base, _ => return None } }
29        None
30    }
31    pub(crate) fn shape_line(&mut self, bytes: &[u8], limit: Option<usize>) -> bool {
32        if !self.shaping.enabled { return false; }
33        let n=limit.unwrap_or(bytes.len()).min(bytes.len());
34        let n=bytes[..n].iter().position(|b| *b==0 || *b==b'\n').unwrap_or(n);
35        let Ok(text)=core::str::from_utf8(&bytes[..n]) else { return false; };
36        let render_font=if self.shape_face(self.font).is_some() { self.font } else { match self.shaping.fallbacks.first() { Some(v)=>v.0,None=>return false } };
37        if self.shape_face(render_font).is_none() { return false; }
38        let serial=self.shape_serial(render_font); // an instance of a variable font: its own engine
39        if self.shaping.serial!=serial || self.shaping.engine.is_none() {
40            let engine=self.shape_engine(render_font);
41            self.shaping.engine=engine; self.shaping.serial=serial; self.shaping.text.clear(); self.shaping.size=0;
42        }
43        if self.shaping.engine.is_none() { return false; }
44        if self.shaping.font==self.font && self.shaping.size==self.size && self.shaping.text==text { return true; }
45        if self.system_fallback() { self.shape_system_fallbacks(text, render_font); }
46        let fallback_engines:Vec<_>=self.shaping.fallbacks.iter().map(|v|&v.1).collect();
47        let Some(glyphs)=self.shaping.engine.as_ref().and_then(|e| e.shape_with_fallback(text,&fallback_engines)) else { return false; };
48        let classic=self.classic_metrics(self.font);
49        let scale=|v:i32,font:u32| { let n=(v as i64*self.size as i64/self.upem(font).max(1) as i64).clamp(i32::MIN as i64,i32::MAX as i64) as i32; if classic { n.saturating_add(128)&!255 } else { n } };
50        let mut pen=0i32; let mut placed=Vec::new(); let mut carets=Vec::new(); let mut segments=Vec::new();
51        let mut i=0;
52        while i<glyphs.len() {
53            let first=glyphs[i]; let left=pen;
54            while i<glyphs.len() && glyphs[i].cluster==first.cluster {
55                let g=glyphs[i];
56                let font=if g.font==0 { render_font } else { self.shaping.fallbacks[g.font-1].0 };
57                placed.push(Placed { font, id:g.id, x:pen.saturating_add(scale(g.x,font)), y:scale(g.y,font) });
58                pen=pen.saturating_add(scale(g.advance,font)); i+=1;
59            }
60            let right=pen; let (begin,end)=if first.rtl { (right,left) } else { (left,right) };
61            carets.push((first.cluster,begin));
62            // Expose legal UTF-8 caret boundaries even for multi-character ligatures.
63            let chars:Vec<_>=text[first.cluster..first.end].char_indices().map(|(o,_)| first.cluster+o).collect();
64            for (k,&index) in chars.iter().enumerate() {
65                let a=begin+((end-begin) as i64*k as i64/chars.len() as i64) as i32;
66                let b=begin+((end-begin) as i64*(k+1) as i64/chars.len() as i64) as i32;
67                segments.push((index,chars.get(k+1).copied().unwrap_or(first.end),a.min(b),a.max(b)));
68            }
69            for (k,&index) in chars.iter().enumerate().skip(1) {
70                carets.push((index,begin+((end-begin) as i64*k as i64/chars.len() as i64) as i32));
71            }
72            carets.push((first.end,end));
73        }
74        if carets.is_empty() { carets.push((0,0)); }
75        carets.sort_by_key(|c| c.0); carets.dedup_by_key(|c| c.0);
76        self.shaping.text=String::from(text); self.shaping.font=self.font; self.shaping.size=self.size;
77        self.shaping.glyphs=placed; self.shaping.carets=carets; self.shaping.width=pen; self.shaping.segments=segments;
78        true
79    }
80    // system fonts for the characters neither the font nor the fallback engines have
81    fn shape_system_fallbacks(&mut self, text: &str, render_font: u32) {
82        let mut need: Vec<u32> = Vec::new();
83        for ch in text.chars() {
84            let cp = ch as u32;
85            if self.has(render_font, cp) || self.shaping.fallbacks.iter().any(|f| self.has(f.0, cp)) { continue; }
86            if let Some(id) = self.fallback_for(cp) {
87                if !need.contains(&id) && !self.shaping.fallbacks.iter().any(|f| f.0 == id) { need.push(id); }
88            }
89        }
90        for id in need {
91            if self.shaping.fallbacks.len() >= 16 { break; }
92            let engine = self.shape_engine(id);
93            if let Some(e) = engine { self.shaping.fallbacks.push((id, e)); self.shaping.size = 0; }
94        }
95    }
96    pub(crate) fn shaped_draw(&mut self, pen0: i32, mut target: Option<(&mut gfx::Dc,&mut gfx::Surface)>) -> i32 {
97        let baseline=self.run_y;
98        for i in 0..self.shaping.glyphs.len() {
99            let g=self.shaping.glyphs[i];
100            if let Some((dc,sf))=&mut target {
101                self.run_y=baseline-(g.y.saturating_add(128)>>8);
102                if !self.color_glyph(dc,sf,g.font,g.id,pen0.saturating_add(g.x)) { self.glyph_draw(dc,sf,g.font,g.id,pen0.saturating_add(g.x),true); }
103            }
104        }
105        self.run_y=baseline; self.shaping.width
106    }
107    pub(crate) fn shaped_caret(&self, index: usize) -> i32 {
108        self.shaping.carets.iter().min_by_key(|c| c.0.abs_diff(index)).map_or(0,|c| c.1.saturating_add(128)>>8)
109    }
110    pub(crate) fn shaped_hit(&self, x: i32) -> usize {
111        self.shaping.carets.iter().min_by_key(|c| ((c.1 as i64)-(x as i64*256)).abs()).map_or(0,|c| c.0)
112    }
113    /// Visual spans for a logical UTF-8 selection. Mixed bidi text may require
114    /// disjoint rectangles; the two endpoint carets alone are not sufficient.
115    pub fn selection_spans(&mut self, text: &[u8], start: usize, end: usize) -> Vec<(i32,i32)> {
116        if start>=end { return Vec::new(); }
117        if !self.shape_line(text,None) {
118            let a=self.caret_x(text,start); let b=self.caret_x(text,end);
119            return alloc::vec![(a.min(b),a.max(b))];
120        }
121        let mut spans:Vec<_>=self.shaping.segments.iter().filter(|s|s.0<end && s.1>start)
122            .map(|s|((s.2+128)>>8,(s.3+128)>>8)).collect();
123        spans.sort_unstable();
124        let mut merged:Vec<(i32,i32)>=Vec::new();
125        for (a,b) in spans {
126            if let Some(last)=merged.last_mut() { if a<=last.1 { last.1=last.1.max(b); continue; } }
127            merged.push((a,b));
128        }
129        merged
130    }
131}