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
80pub 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)]
91pub struct SvgRenderer {
93 asset_source: Arc<dyn AssetSource>,
94 usvg_options: Arc<usvg::Options<'static>>,
95}
96
97pub struct ParsedSvg(usvg::Tree);
104
105#[derive(Clone, Copy, Debug)]
107pub struct SvgTextFont<'a> {
108 pub family: &'a str,
110 pub size: f32,
112 pub weight: &'a str,
114 pub style: &'a str,
116}
117
118#[derive(Clone, Copy)]
120pub enum SvgSize {
121 Size(Size<DevicePixels>),
123 ExactSize(Size<DevicePixels>),
125 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 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 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 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 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 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 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 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 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(¶ms.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 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 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("&"),
487 '<' => xml.push_str("<"),
488 '>' => xml.push_str(">"),
489 '"' => xml.push_str("""),
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
511fn 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 (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 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 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 ("©️", 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}