Skip to main content

gpui/
svg_renderer.rs

1use crate::{
2    AssetSource, DevicePixels, IsZero, RenderImage, Result, SharedString, Size,
3    swap_rgba_pa_to_bgra,
4};
5use collections::HashMap;
6use image::Frame;
7use parking_lot::Mutex;
8use resvg::tiny_skia::Pixmap;
9use smallvec::SmallVec;
10use std::{
11    hash::Hash,
12    path::Path,
13    sync::{Arc, LazyLock, OnceLock},
14};
15
16#[cfg(target_os = "macos")]
17const EMOJI_FONT_FAMILIES: &[&str] = &["Apple Color Emoji", ".AppleColorEmojiUI"];
18
19#[cfg(target_os = "windows")]
20const EMOJI_FONT_FAMILIES: &[&str] = &["Segoe UI Emoji", "Segoe UI Symbol"];
21
22#[cfg(any(target_os = "linux", target_os = "freebsd"))]
23const EMOJI_FONT_FAMILIES: &[&str] = &[
24    "Noto Color Emoji",
25    "Emoji One",
26    "Twitter Color Emoji",
27    "JoyPixels",
28];
29
30#[cfg(not(any(
31    target_os = "macos",
32    target_os = "windows",
33    target_os = "linux",
34    target_os = "freebsd",
35)))]
36const EMOJI_FONT_FAMILIES: &[&str] = &[];
37
38fn is_emoji_presentation(c: char) -> bool {
39    icu_properties::CodePointSetData::new::<icu_properties::props::EmojiPresentation>().contains(c)
40}
41
42fn font_has_char(db: &usvg::fontdb::Database, id: usvg::fontdb::ID, ch: char) -> bool {
43    db.with_face_data(id, |font_data, face_index| {
44        ttf_parser::Face::parse(font_data, face_index)
45            .ok()
46            .and_then(|face| face.glyph_index(ch))
47            .is_some()
48    })
49    .unwrap_or(false)
50}
51
52fn select_emoji_font(
53    ch: char,
54    fonts: &[usvg::fontdb::ID],
55    db: &usvg::fontdb::Database,
56    families: &[&str],
57) -> Option<usvg::fontdb::ID> {
58    for family_name in families {
59        let query = usvg::fontdb::Query {
60            families: &[usvg::fontdb::Family::Name(family_name)],
61            weight: usvg::fontdb::Weight(400),
62            stretch: usvg::fontdb::Stretch::Normal,
63            style: usvg::fontdb::Style::Normal,
64        };
65
66        let Some(id) = db.query(&query) else {
67            continue;
68        };
69
70        if fonts.contains(&id) || !font_has_char(db, id, ch) {
71            continue;
72        }
73
74        return Some(id);
75    }
76
77    None
78}
79
80/// When rendering SVGs, we render them at twice the size to get a higher-quality result.
81pub const SMOOTH_SVG_SCALE_FACTOR: f32 = 2.;
82
83#[derive(Clone, PartialEq, Hash, Eq)]
84#[expect(missing_docs)]
85pub struct RenderSvgParams {
86    pub path: SharedString,
87    pub size: Size<DevicePixels>,
88}
89
90#[derive(Clone)]
91/// A struct holding everything necessary to render SVGs.
92pub struct SvgRenderer {
93    asset_source: Arc<dyn AssetSource>,
94    usvg_options: Arc<usvg::Options<'static>>,
95}
96
97/// A parsed SVG document that can be rasterized at any scale.
98///
99/// Produced by [`SvgRenderer::parse_svg`] and rasterized by
100/// [`SvgRenderer::render_parsed`]. Parsing resolves fonts and converts text
101/// to paths, so callers that need to rasterize the same SVG at multiple
102/// scales should retain this value to avoid re-paying the parse cost.
103pub struct ParsedSvg(usvg::Tree);
104
105/// The font of an SVG `<text>` element, as the values of its presentation attributes.
106#[derive(Clone, Copy, Debug)]
107pub struct SvgTextFont<'a> {
108    /// The `font-family` list.
109    pub family: &'a str,
110    /// The `font-size`, in pixels.
111    pub size: f32,
112    /// The `font-weight`.
113    pub weight: &'a str,
114    /// The `font-style`.
115    pub style: &'a str,
116}
117
118/// The size in which to rasterize the SVG.
119#[derive(Clone, Copy)]
120pub enum SvgSize {
121    /// A width in device pixels. The SVG retains its aspect ratio.
122    Size(Size<DevicePixels>),
123    /// An exact width and height in device pixels.
124    ExactSize(Size<DevicePixels>),
125    /// A logical scaling factor to apply to the size provided by the SVG.
126    ScaleFactor(f32),
127}
128
129impl From<f32> for SvgSize {
130    fn from(scale_factor: f32) -> Self {
131        Self::ScaleFactor(scale_factor)
132    }
133}
134
135impl SvgRenderer {
136    /// Creates a new SVG renderer with the provided asset source.
137    pub fn new(asset_source: Arc<dyn AssetSource>) -> Self {
138        static SYSTEM_FONT_DB: LazyLock<Arc<usvg::fontdb::Database>> = LazyLock::new(|| {
139            let mut db = usvg::fontdb::Database::new();
140            db.load_system_fonts();
141            Arc::new(db)
142        });
143
144        // Build the enriched font DB lazily on first SVG render rather than
145        // eagerly at construction time. This avoids the expensive deep-clone
146        // of the system font database for code paths that never render SVGs
147        // (e.g. tests).
148        let enriched_fontdb = Arc::new(OnceLock::<Mutex<FontDatabase>>::new());
149
150        let default_font_resolver = usvg::FontResolver::default_font_selector();
151        let font_resolver = Box::new({
152            let asset_source = asset_source.clone();
153            let enriched_fontdb = enriched_fontdb.clone();
154            move |font: &usvg::Font, db: &mut Arc<usvg::fontdb::Database>| {
155                let fontdb = enriched_fontdb.get_or_init(|| {
156                    let mut db = (**SYSTEM_FONT_DB).clone();
157                    load_bundled_fonts(&*asset_source, &mut db);
158                    fix_generic_font_families(&mut db);
159                    Mutex::new(FontDatabase {
160                        database: Arc::new(db),
161                        owned_faces: HashMap::default(),
162                        remaining_owned_bytes: MAX_OWNED_FONT_BYTES,
163                        fallback_faces: HashMap::default(),
164                    })
165                });
166                if db.is_empty() {
167                    *db = fontdb.lock().database.clone();
168                }
169                let id = default_font_resolver(font, db).or_else(|| {
170                    // fontdb doesn't recognize CSS system font keywords like "system-ui"
171                    // or "ui-sans-serif", so fall back to sans-serif before any face.
172                    let sans_query = usvg::fontdb::Query {
173                        families: &[usvg::fontdb::Family::SansSerif],
174                        ..Default::default()
175                    };
176                    db.query(&sans_query)
177                        .or_else(|| db.faces().next().map(|f| f.id))
178                })?;
179                Some(fontdb.lock().owned_face(db, id))
180            }
181        });
182        let default_fallback_selection = usvg::FontResolver::default_fallback_selector();
183        let fallback_selection = Box::new(
184            move |ch: char, fonts: &[usvg::fontdb::ID], db: &mut Arc<usvg::fontdb::Database>| {
185                let mut select = |fonts: &[usvg::fontdb::ID]| {
186                    if is_emoji_presentation(ch) {
187                        if let Some(id) =
188                            select_emoji_font(ch, fonts, db.as_ref(), EMOJI_FONT_FAMILIES)
189                        {
190                            return Some(id);
191                        }
192                    }
193
194                    default_fallback_selection(ch, fonts, db)
195                };
196                let Some(fontdb) = enriched_fontdb.get() else {
197                    return select(fonts);
198                };
199                let face = cached_fallback_face(fontdb, ch, fonts, select)?;
200                let owned_face = fontdb.lock().owned_face(db, face);
201                Some(if fonts.contains(&owned_face) {
202                    face
203                } else {
204                    owned_face
205                })
206            },
207        );
208        let options = usvg::Options {
209            font_resolver: usvg::FontResolver {
210                select_font: font_resolver,
211                select_fallback: fallback_selection,
212            },
213            ..Default::default()
214        };
215        Self {
216            asset_source,
217            usvg_options: Arc::new(options),
218        }
219    }
220
221    /// Parses SVG data into a [`ParsedSvg`] that can be rasterized at any scale.
222    pub fn parse_svg(&self, bytes: &[u8]) -> Result<ParsedSvg, usvg::Error> {
223        usvg::Tree::from_data(bytes, &self.usvg_options).map(ParsedSvg)
224    }
225
226    /// Returns the advance of `text` drawn by this renderer as a single line of SVG `<text>`.
227    pub fn measure_text_width(
228        &self,
229        text: &str,
230        font: &SvgTextFont<'_>,
231    ) -> Result<f32, usvg::Error> {
232        let mut svg = String::from(
233            r#"<svg xmlns="http://www.w3.org/2000/svg"><text xml:space="preserve" text-decoration="underline" font-family=""#,
234        );
235        push_xml_escaped(&mut svg, font.family);
236        svg.push_str(r#"" font-weight=""#);
237        push_xml_escaped(&mut svg, font.weight);
238        svg.push_str(r#"" font-style=""#);
239        push_xml_escaped(&mut svg, font.style);
240        let size = font.size;
241        svg.push_str(&format!(r#"" font-size="{size}">"#));
242        push_xml_escaped(&mut svg, text);
243        svg.push_str("</text></svg>");
244
245        let tree = usvg::Tree::from_str(&svg, &self.usvg_options)?;
246        Ok(underline_width(tree.root()))
247    }
248
249    /// Rasterizes a previously parsed SVG into an image buffer.
250    pub fn render_parsed(
251        &self,
252        svg: &ParsedSvg,
253        size: impl Into<SvgSize>,
254    ) -> Result<Arc<RenderImage>, usvg::Error> {
255        let (size, image_scale_factor) = match size.into() {
256            SvgSize::Size(size) => (SvgSize::Size(size), 1.0),
257            SvgSize::ExactSize(size) => (SvgSize::ExactSize(size), 1.0),
258            SvgSize::ScaleFactor(scale_factor) => (
259                SvgSize::ScaleFactor(scale_factor * SMOOTH_SVG_SCALE_FACTOR),
260                SMOOTH_SVG_SCALE_FACTOR,
261            ),
262        };
263        let pixmap = rasterize_tree(&svg.0, size)?;
264        let mut buffer =
265            image::ImageBuffer::from_raw(pixmap.width(), pixmap.height(), pixmap.take()).unwrap();
266
267        for pixel in buffer.chunks_exact_mut(4) {
268            swap_rgba_pa_to_bgra(pixel);
269        }
270
271        let mut image = RenderImage::new(SmallVec::from_const([Frame::new(buffer)]));
272        image.scale_factor = image_scale_factor;
273        Ok(Arc::new(image))
274    }
275
276    /// Renders the given bytes into an image buffer.
277    pub fn render_single_frame(
278        &self,
279        bytes: &[u8],
280        scale_factor: f32,
281    ) -> Result<Arc<RenderImage>, usvg::Error> {
282        let svg = self.parse_svg(bytes)?;
283        self.render_parsed(&svg, scale_factor)
284    }
285
286    pub(crate) fn render_alpha_mask(
287        &self,
288        params: &RenderSvgParams,
289        bytes: Option<&[u8]>,
290    ) -> Result<Option<(Size<DevicePixels>, Vec<u8>)>> {
291        anyhow::ensure!(!params.size.is_zero(), "can't render at a zero size");
292
293        let render_pixmap = |bytes| {
294            let pixmap = self.render_pixmap(bytes, SvgSize::Size(params.size))?;
295
296            // Convert the pixmap's pixels into an alpha mask.
297            let size = Size::new(
298                DevicePixels(pixmap.width() as i32),
299                DevicePixels(pixmap.height() as i32),
300            );
301            let alpha_mask = pixmap
302                .pixels()
303                .iter()
304                .map(|p| p.alpha())
305                .collect::<Vec<_>>();
306
307            Ok(Some((size, alpha_mask)))
308        };
309
310        if let Some(bytes) = bytes {
311            render_pixmap(bytes)
312        } else if let Some(bytes) = self.asset_source.load(&params.path)? {
313            render_pixmap(&bytes)
314        } else {
315            Ok(None)
316        }
317    }
318
319    fn render_pixmap(&self, bytes: &[u8], size: SvgSize) -> Result<Pixmap, usvg::Error> {
320        let tree = usvg::Tree::from_data(bytes, &self.usvg_options)?;
321        rasterize_tree(&tree, size)
322    }
323}
324
325fn rasterize_tree(tree: &usvg::Tree, size: SvgSize) -> Result<Pixmap, usvg::Error> {
326    // Cap the size of the rendered pixmap to avoid texture allocation panics
327    // Related issue: #56466
328    const MAX_SIZE: f32 = 8192.0;
329
330    let svg_size = tree.size();
331    let (mut width, mut height) = match size {
332        SvgSize::Size(size) => {
333            let scale = i32::from(size.width) as f32 / svg_size.width();
334            (svg_size.width() * scale, svg_size.height() * scale)
335        }
336        SvgSize::ExactSize(size) => (i32::from(size.width) as f32, i32::from(size.height) as f32),
337        SvgSize::ScaleFactor(scale) => (svg_size.width() * scale, svg_size.height() * scale),
338    };
339
340    if width > MAX_SIZE {
341        log::warn!("Attempted to render pixmap where width ({width}) > MAX_SIZE ({MAX_SIZE})");
342    }
343    if height > MAX_SIZE {
344        log::warn!("Attempted to render pixmap where height ({height}) > MAX_SIZE ({MAX_SIZE})");
345    }
346    let scale = (MAX_SIZE / width).min(MAX_SIZE / height).min(1.0);
347    width *= scale;
348    height *= scale;
349
350    // Render the SVG to a pixmap with the specified width and height.
351    let mut pixmap = resvg::tiny_skia::Pixmap::new(width as u32, height as u32)
352        .ok_or(usvg::Error::InvalidSize)?;
353
354    let transform = resvg::tiny_skia::Transform::from_scale(
355        width / svg_size.width(),
356        height / svg_size.height(),
357    );
358
359    resvg::render(tree, transform, &mut pixmap.as_mut());
360
361    Ok(pixmap)
362}
363
364const MAX_OWNED_FONT_BYTES: u64 = 64 * 1024 * 1024;
365
366struct FontDatabase {
367    database: Arc<usvg::fontdb::Database>,
368    owned_faces: HashMap<usvg::fontdb::ID, usvg::fontdb::ID>,
369    remaining_owned_bytes: u64,
370    fallback_faces: HashMap<(usvg::fontdb::ID, char), Option<usvg::fontdb::ID>>,
371}
372
373impl FontDatabase {
374    fn owned_face(
375        &mut self,
376        db: &mut Arc<usvg::fontdb::Database>,
377        id: usvg::fontdb::ID,
378    ) -> usvg::fontdb::ID {
379        let Some(usvg::fontdb::Source::File(path)) = db.face(id).map(|face| face.source.clone())
380        else {
381            return id;
382        };
383        if !self.owned_faces.contains_key(&id) {
384            self.own_font_file(&path);
385        }
386        *db = self.database.clone();
387        self.owned_faces.get(&id).copied().unwrap_or(id)
388    }
389
390    fn own_font_file(&mut self, path: &Path) {
391        let file_faces = self
392            .database
393            .faces()
394            .filter(|face| {
395                matches!(&face.source, usvg::fontdb::Source::File(face_path) if face_path == path)
396            })
397            .map(|face| (face.id, face.index))
398            .collect::<Vec<_>>();
399        let remaining_owned_bytes = self.remaining_owned_bytes;
400        let data = std::fs::metadata(path).and_then(|metadata| {
401            (metadata.len() <= remaining_owned_bytes)
402                .then(|| std::fs::read(path))
403                .transpose()
404        });
405        let owned_ids = match data {
406            Ok(Some(data)) if data.len() as u64 <= remaining_owned_bytes => {
407                let size = data.len() as u64;
408                let owned_ids = Arc::make_mut(&mut self.database)
409                    .load_font_source(usvg::fontdb::Source::Binary(Arc::new(data)));
410                if !owned_ids.is_empty() {
411                    self.remaining_owned_bytes -= size;
412                }
413                owned_ids
414            }
415            Ok(_) => Default::default(),
416            Err(error) => {
417                log::warn!("Failed to read font {path:?}: {error}");
418                Default::default()
419            }
420        };
421        for (id, index) in file_faces {
422            let owned_id = owned_ids
423                .iter()
424                .copied()
425                .find(|owned_id| {
426                    self.database
427                        .face(*owned_id)
428                        .is_some_and(|face| face.index == index)
429                })
430                .unwrap_or(id);
431            self.owned_faces.insert(id, owned_id);
432        }
433    }
434}
435
436const MAX_CACHED_FALLBACK_FACES: usize = 16 * 1024;
437
438fn cached_fallback_face(
439    fontdb: &Mutex<FontDatabase>,
440    ch: char,
441    fonts: &[usvg::fontdb::ID],
442    mut select: impl FnMut(&[usvg::fontdb::ID]) -> Option<usvg::fontdb::ID>,
443) -> Option<usvg::fontdb::ID> {
444    let Some(base) = fonts.first() else {
445        return select(fonts);
446    };
447    let key = (*base, ch);
448    let cached_face = fontdb.lock().fallback_faces.get(&key).copied();
449    let face = match cached_face {
450        Some(face) => face,
451        None => {
452            let face = select(&fonts[..1]);
453            let fallback_faces = &mut fontdb.lock().fallback_faces;
454            if fallback_faces.len() < MAX_CACHED_FALLBACK_FACES {
455                fallback_faces.insert(key, face);
456            }
457            face
458        }
459    };
460    match face {
461        Some(face) if fonts.contains(&face) => select(fonts),
462        face => face,
463    }
464}
465
466fn underline_width(group: &usvg::Group) -> f32 {
467    group.children().iter().fold(0., |width, node| {
468        width
469            + match node {
470                usvg::Node::Text(text) => text
471                    .layouted()
472                    .iter()
473                    .filter_map(|span| span.underline.as_ref())
474                    .fold(0., |width, underline| {
475                        width + underline.data().bounds().width()
476                    }),
477                usvg::Node::Group(group) => underline_width(group),
478                usvg::Node::Path(_) | usvg::Node::Image(_) => 0.,
479            }
480    })
481}
482
483fn push_xml_escaped(xml: &mut String, text: &str) {
484    for character in text.chars() {
485        match character {
486            '&' => xml.push_str("&amp;"),
487            '<' => xml.push_str("&lt;"),
488            '>' => xml.push_str("&gt;"),
489            '"' => xml.push_str("&quot;"),
490            '\t' | '\n' | '\r' => xml.push(character),
491            '\u{0}'..='\u{1f}' | '\u{fffe}' | '\u{ffff}' => {}
492            _ => xml.push(character),
493        }
494    }
495}
496
497fn load_bundled_fonts(asset_source: &dyn AssetSource, db: &mut usvg::fontdb::Database) {
498    let font_paths = [
499        "fonts/ibm-plex-sans/IBMPlexSans-Regular.ttf",
500        "fonts/lilex/Lilex-Regular.ttf",
501    ];
502    for path in font_paths {
503        match asset_source.load(path) {
504            Ok(Some(data)) => db.load_font_data(data.into_owned()),
505            Ok(None) => log::warn!("Bundled font not found: {path}"),
506            Err(error) => log::warn!("Failed to load bundled font {path}: {error}"),
507        }
508    }
509}
510
511// fontdb defaults generic families to Microsoft fonts ("Arial", "Times New Roman")
512// which aren't installed on most Linux systems. fontconfig normally overrides these,
513// but when it fails the defaults remain and all generic family queries return None.
514fn fix_generic_font_families(db: &mut usvg::fontdb::Database) {
515    use usvg::fontdb::{Family, Query};
516
517    let families_and_fallbacks: &[(Family<'_>, &str)] = &[
518        (Family::SansSerif, "IBM Plex Sans"),
519        // No serif font bundled; use sans-serif as best available fallback.
520        (Family::Serif, "IBM Plex Sans"),
521        (Family::Monospace, "Lilex"),
522        (Family::Cursive, "IBM Plex Sans"),
523        (Family::Fantasy, "IBM Plex Sans"),
524    ];
525
526    for (family, fallback_name) in families_and_fallbacks {
527        let query = Query {
528            families: &[*family],
529            ..Default::default()
530        };
531        if db.query(&query).is_none() {
532            match family {
533                Family::SansSerif => db.set_sans_serif_family(*fallback_name),
534                Family::Serif => db.set_serif_family(*fallback_name),
535                Family::Monospace => db.set_monospace_family(*fallback_name),
536                Family::Cursive => db.set_cursive_family(*fallback_name),
537                Family::Fantasy => db.set_fantasy_family(*fallback_name),
538                _ => {}
539            }
540        }
541    }
542}
543
544#[cfg(test)]
545mod tests {
546    use super::*;
547    use std::{borrow::Cow, cell::Cell};
548    use usvg::fontdb::{Database, Family, Query};
549
550    const IBM_PLEX_REGULAR: &[u8] =
551        include_bytes!("../../../assets/fonts/ibm-plex-sans/IBMPlexSans-Regular.ttf");
552    const LILEX_REGULAR: &[u8] = include_bytes!("../../../assets/fonts/lilex/Lilex-Regular.ttf");
553
554    #[test]
555    fn renders_parsed_svg_at_requested_size() -> Result<()> {
556        let renderer = SvgRenderer::new(Arc::new(()));
557        let svg = renderer.parse_svg(
558            br#"<svg xmlns="http://www.w3.org/2000/svg" width="24pt" height="12pt"></svg>"#,
559        )?;
560        let requested_size = Size::new(DevicePixels(24), DevicePixels(12));
561        let image = renderer.render_parsed(&svg, SvgSize::ExactSize(requested_size))?;
562
563        assert_eq!(image.size(0), requested_size);
564        Ok(())
565    }
566
567    #[test]
568    fn preserves_aspect_ratio_for_width_constrained_size() -> Result<()> {
569        let renderer = SvgRenderer::new(Arc::new(()));
570        let svg = renderer.parse_svg(
571            br#"<svg xmlns="http://www.w3.org/2000/svg" width="24pt" height="12pt"></svg>"#,
572        )?;
573        let image = renderer.render_parsed(
574            &svg,
575            SvgSize::Size(Size::new(DevicePixels(24), DevicePixels(24))),
576        )?;
577
578        assert_eq!(image.size(0), Size::new(DevicePixels(24), DevicePixels(12)));
579        Ok(())
580    }
581
582    #[test]
583    fn measured_text_width_matches_rasterized_advance() -> Result<()> {
584        let renderer = SvgRenderer::new(Arc::new(BundledFonts));
585        let font = SvgTextFont {
586            family: "IBM Plex Sans",
587            size: 40.,
588            weight: "normal",
589            style: "normal",
590        };
591        let frame_width = rasterized_text_width(&renderer, "MM")?;
592        assert!(frame_width > 0.);
593
594        for text in ["MMMM", " ", "   ", "\u{a0}", "\u{200b}", "M\u{200b}"] {
595            let measured = renderer.measure_text_width(text, &font)?;
596            let rasterized = rasterized_text_width(&renderer, &format!("M{text}M"))? - frame_width;
597            assert!(
598                (measured - rasterized).abs() <= 1.,
599                "{text:?} measured {measured}px, rasterized {rasterized}px"
600            );
601        }
602        assert_eq!(
603            renderer.measure_text_width("M\u{200b}", &font)?,
604            renderer.measure_text_width("M", &font)?
605        );
606        assert!(renderer.measure_text_width("<&\"\u{1}>", &font)? > 0.);
607        Ok(())
608    }
609
610    #[test]
611    fn owns_font_bytes_within_budget() -> Result<()> {
612        let font_path = |name| {
613            std::env::temp_dir().join(format!(
614                "gpui-svg-renderer-{}-{name}.ttf",
615                std::process::id()
616            ))
617        };
618        let (plex_path, lilex_path) = (font_path("plex"), font_path("lilex"));
619        std::fs::write(&plex_path, IBM_PLEX_REGULAR)?;
620        std::fs::write(&lilex_path, LILEX_REGULAR)?;
621        let mut database = Database::new();
622        database.load_font_file(&plex_path)?;
623        database.load_font_file(&lilex_path)?;
624        let mut fonts = FontDatabase {
625            database: Arc::new(database),
626            owned_faces: HashMap::default(),
627            remaining_owned_bytes: IBM_PLEX_REGULAR.len() as u64,
628            fallback_faces: HashMap::default(),
629        };
630        let mut db = fonts.database.clone();
631        let face_ids = db.faces().map(|face| face.id).collect::<Vec<_>>();
632        let (plex_id, lilex_id) = (face_ids[0], face_ids[1]);
633
634        let owned_plex_id = fonts.owned_face(&mut db, plex_id);
635        let owned_lilex_id = fonts.owned_face(&mut db, lilex_id);
636        std::fs::write(&plex_path, b"changed")?;
637        let data_len = |id| db.with_face_data(id, |data, _| data.len());
638        let data_lens = (data_len(plex_id), data_len(owned_plex_id));
639        std::fs::remove_file(&plex_path)?;
640        std::fs::remove_file(&lilex_path)?;
641
642        assert_eq!(data_lens, (Some(7), Some(IBM_PLEX_REGULAR.len())));
643        assert_eq!(owned_lilex_id, lilex_id);
644        assert_eq!(fonts.remaining_owned_bytes, 0);
645        assert_eq!(fonts.owned_face(&mut db, plex_id), owned_plex_id);
646        Ok(())
647    }
648
649    #[test]
650    fn fallback_faces_are_remembered_until_excluded() {
651        let database = db_with_bundled_fonts();
652        let face_ids = database.faces().map(|face| face.id).collect::<Vec<_>>();
653        let (base, fallback) = (face_ids[0], face_ids[1]);
654        let fontdb = Mutex::new(FontDatabase {
655            database: Arc::new(database),
656            owned_faces: HashMap::default(),
657            remaining_owned_bytes: 0,
658            fallback_faces: HashMap::default(),
659        });
660        let selections = Cell::new(0);
661        let fallback_face = |ch, fonts: &[usvg::fontdb::ID]| {
662            cached_fallback_face(&fontdb, ch, fonts, |excluded| {
663                selections.set(selections.get() + 1);
664                (!excluded.contains(&fallback)).then_some(fallback)
665            })
666        };
667
668        assert_eq!(fallback_face('x', &[base]), Some(fallback));
669        assert_eq!(fallback_face('x', &[base]), Some(fallback));
670        assert_eq!(selections.get(), 1);
671        assert_eq!(fallback_face('x', &[base, fallback]), None);
672        assert_eq!(selections.get(), 2);
673        assert_eq!(fallback_face('y', &[base, fallback]), None);
674        assert_eq!(selections.get(), 4);
675        assert_eq!(fallback_face('y', &[base]), Some(fallback));
676        assert_eq!(selections.get(), 4);
677    }
678
679    fn db_with_bundled_fonts() -> Database {
680        let mut db = Database::new();
681        db.load_font_data(IBM_PLEX_REGULAR.to_vec());
682        db.load_font_data(LILEX_REGULAR.to_vec());
683        db
684    }
685
686    #[test]
687    fn text_with_split_glyph_clusters_in_mixed_fonts_does_not_panic() {
688        let mut db = Database::new();
689        db.load_font_data(IBM_PLEX_REGULAR.to_vec());
690        db.load_font_data(LILEX_REGULAR.to_vec());
691        let options = usvg::Options {
692            fontdb: std::sync::Arc::new(db),
693            ..Default::default()
694        };
695
696        // A base letter followed by a stack of combining marks. Under HarfBuzz's
697        // default cluster merging every mark glyph shares the base's byte index,
698        // which is the "glyph splitting" condition that triggered the panic. The
699        // chunk must use two different fonts so the buggy merge path runs.
700        let zalgo = "e\u{0301}\u{0302}\u{0303}\u{0304}\u{0306}\u{0307}\u{0308}\u{030a}";
701        let svg = format!(
702            r#"<svg viewBox="0 0 200 200" xmlns="http://www.w3.org/2000/svg"><text font-family="Lilex" font-size="32">{zalgo}<tspan font-family="IBM Plex Sans">{zalgo}</tspan></text></svg>"#
703        );
704
705        // Before the fix this aborts via panic with a message like
706        // "removal index (is 5) should be < len (is 5)".
707        usvg::Tree::from_data(svg.as_bytes(), &options)
708            .expect("SVG with mixed-font text should parse");
709    }
710
711    #[test]
712    fn test_is_emoji_presentation() {
713        let cases = [
714            ("a", false),
715            ("Z", false),
716            ("1", false),
717            ("#", false),
718            ("*", false),
719            ("漢", false),
720            ("中", false),
721            ("カ", false),
722            ("©", false),
723            ("♥", false),
724            ("😀", true),
725            ("✅", true),
726            ("🇺🇸", true),
727            // SVG fallback is not cluster-aware yet
728            ("©️", false),
729            ("♥️", false),
730            ("1️⃣", false),
731        ];
732        for (s, expected) in cases {
733            assert_eq!(
734                is_emoji_presentation(s.chars().next().unwrap()),
735                expected,
736                "for char {:?}",
737                s
738            );
739        }
740    }
741
742    #[test]
743    fn fix_generic_font_families_sets_all_families() {
744        let mut db = db_with_bundled_fonts();
745        fix_generic_font_families(&mut db);
746
747        let families = [
748            Family::SansSerif,
749            Family::Serif,
750            Family::Monospace,
751            Family::Cursive,
752            Family::Fantasy,
753        ];
754
755        for family in families {
756            let query = Query {
757                families: &[family],
758                ..Default::default()
759            };
760            assert!(
761                db.query(&query).is_some(),
762                "Expected generic family {family:?} to resolve after fix_generic_font_families"
763            );
764        }
765    }
766
767    #[test]
768    fn test_select_emoji_font_skips_family_without_glyph() {
769        let db = db_with_bundled_fonts();
770
771        let ibm_plex_sans = db
772            .query(&usvg::fontdb::Query {
773                families: &[usvg::fontdb::Family::Name("IBM Plex Sans")],
774                weight: usvg::fontdb::Weight(400),
775                stretch: usvg::fontdb::Stretch::Normal,
776                style: usvg::fontdb::Style::Normal,
777            })
778            .unwrap();
779        let lilex = db
780            .query(&usvg::fontdb::Query {
781                families: &[usvg::fontdb::Family::Name("Lilex")],
782                weight: usvg::fontdb::Weight(400),
783                stretch: usvg::fontdb::Stretch::Normal,
784                style: usvg::fontdb::Style::Normal,
785            })
786            .unwrap();
787        let selected = select_emoji_font('│', &[], &db, &["IBM Plex Sans", "Lilex"]).unwrap();
788
789        assert_eq!(selected, lilex);
790        assert!(!font_has_char(&db, ibm_plex_sans, '│'));
791        assert!(font_has_char(&db, selected, '│'));
792    }
793
794    #[test]
795    fn fix_generic_font_families_monospace_resolves_to_lilex() {
796        let mut db = db_with_bundled_fonts();
797        fix_generic_font_families(&mut db);
798
799        let query = Query {
800            families: &[Family::Monospace],
801            ..Default::default()
802        };
803        let id = db.query(&query).expect("Monospace should resolve");
804        let face = db.face(id).expect("Face should exist");
805        assert!(
806            face.families.iter().any(|(name, _)| name.contains("Lilex")),
807            "Monospace should map to Lilex, got {:?}",
808            face.families
809        );
810    }
811
812    struct BundledFonts;
813
814    impl AssetSource for BundledFonts {
815        fn load(&self, path: &str) -> Result<Option<Cow<'static, [u8]>>> {
816            Ok(match path {
817                "fonts/ibm-plex-sans/IBMPlexSans-Regular.ttf" => {
818                    Some(Cow::Borrowed(IBM_PLEX_REGULAR))
819                }
820                "fonts/lilex/Lilex-Regular.ttf" => Some(Cow::Borrowed(LILEX_REGULAR)),
821                _ => None,
822            })
823        }
824
825        fn list(&self, _path: &str) -> Result<Vec<SharedString>> {
826            Ok(Vec::new())
827        }
828    }
829
830    fn rasterized_text_width(renderer: &SvgRenderer, text: &str) -> Result<f32> {
831        let svg = format!(
832            r#"<svg xmlns="http://www.w3.org/2000/svg" width="400" height="60"><text xml:space="preserve" x="10" y="45" font-family="IBM Plex Sans" font-size="40">{text}</text></svg>"#
833        );
834        let pixmap = renderer.render_pixmap(svg.as_bytes(), SvgSize::ScaleFactor(1.))?;
835        let width = pixmap.width() as usize;
836        let inked_columns = (0..width)
837            .filter(|column| {
838                pixmap
839                    .pixels()
840                    .iter()
841                    .skip(*column)
842                    .step_by(width)
843                    .any(|pixel| pixel.alpha() > 0)
844            })
845            .collect::<Vec<_>>();
846        Ok(match (inked_columns.first(), inked_columns.last()) {
847            (Some(first), Some(last)) => (last - first + 1) as f32,
848            _ => 0.,
849        })
850    }
851}