use crate::{
AssetSource, DevicePixels, IsZero, RenderImage, Result, SharedString, Size,
swap_rgba_pa_to_bgra,
};
use collections::HashMap;
use image::Frame;
use parking_lot::Mutex;
use resvg::tiny_skia::Pixmap;
use smallvec::SmallVec;
use std::{
hash::Hash,
path::Path,
sync::{Arc, LazyLock, OnceLock},
};
#[cfg(target_os = "macos")]
const EMOJI_FONT_FAMILIES: &[&str] = &["Apple Color Emoji", ".AppleColorEmojiUI"];
#[cfg(target_os = "windows")]
const EMOJI_FONT_FAMILIES: &[&str] = &["Segoe UI Emoji", "Segoe UI Symbol"];
#[cfg(any(target_os = "linux", target_os = "freebsd"))]
const EMOJI_FONT_FAMILIES: &[&str] = &[
"Noto Color Emoji",
"Emoji One",
"Twitter Color Emoji",
"JoyPixels",
];
#[cfg(not(any(
target_os = "macos",
target_os = "windows",
target_os = "linux",
target_os = "freebsd",
)))]
const EMOJI_FONT_FAMILIES: &[&str] = &[];
fn is_emoji_presentation(c: char) -> bool {
icu_properties::CodePointSetData::new::<icu_properties::props::EmojiPresentation>().contains(c)
}
fn font_has_char(db: &usvg::fontdb::Database, id: usvg::fontdb::ID, ch: char) -> bool {
db.with_face_data(id, |font_data, face_index| {
ttf_parser::Face::parse(font_data, face_index)
.ok()
.and_then(|face| face.glyph_index(ch))
.is_some()
})
.unwrap_or(false)
}
fn select_emoji_font(
ch: char,
fonts: &[usvg::fontdb::ID],
db: &usvg::fontdb::Database,
families: &[&str],
) -> Option<usvg::fontdb::ID> {
for family_name in families {
let query = usvg::fontdb::Query {
families: &[usvg::fontdb::Family::Name(family_name)],
weight: usvg::fontdb::Weight(400),
stretch: usvg::fontdb::Stretch::Normal,
style: usvg::fontdb::Style::Normal,
};
let Some(id) = db.query(&query) else {
continue;
};
if fonts.contains(&id) || !font_has_char(db, id, ch) {
continue;
}
return Some(id);
}
None
}
pub const SMOOTH_SVG_SCALE_FACTOR: f32 = 2.;
#[derive(Clone, PartialEq, Hash, Eq)]
#[expect(missing_docs)]
pub struct RenderSvgParams {
pub path: SharedString,
pub size: Size<DevicePixels>,
}
#[derive(Clone)]
pub struct SvgRenderer {
asset_source: Arc<dyn AssetSource>,
usvg_options: Arc<usvg::Options<'static>>,
}
pub struct ParsedSvg(usvg::Tree);
#[derive(Clone, Copy, Debug)]
pub struct SvgTextFont<'a> {
pub family: &'a str,
pub size: f32,
pub weight: &'a str,
pub style: &'a str,
}
#[derive(Clone, Copy)]
pub enum SvgSize {
Size(Size<DevicePixels>),
ExactSize(Size<DevicePixels>),
ScaleFactor(f32),
}
impl From<f32> for SvgSize {
fn from(scale_factor: f32) -> Self {
Self::ScaleFactor(scale_factor)
}
}
impl SvgRenderer {
pub fn new(asset_source: Arc<dyn AssetSource>) -> Self {
static SYSTEM_FONT_DB: LazyLock<Arc<usvg::fontdb::Database>> = LazyLock::new(|| {
let mut db = usvg::fontdb::Database::new();
db.load_system_fonts();
Arc::new(db)
});
let enriched_fontdb = Arc::new(OnceLock::<Mutex<FontDatabase>>::new());
let default_font_resolver = usvg::FontResolver::default_font_selector();
let font_resolver = Box::new({
let asset_source = asset_source.clone();
let enriched_fontdb = enriched_fontdb.clone();
move |font: &usvg::Font, db: &mut Arc<usvg::fontdb::Database>| {
let fontdb = enriched_fontdb.get_or_init(|| {
let mut db = (**SYSTEM_FONT_DB).clone();
load_bundled_fonts(&*asset_source, &mut db);
fix_generic_font_families(&mut db);
Mutex::new(FontDatabase {
database: Arc::new(db),
owned_faces: HashMap::default(),
remaining_owned_bytes: MAX_OWNED_FONT_BYTES,
fallback_faces: HashMap::default(),
})
});
if db.is_empty() {
*db = fontdb.lock().database.clone();
}
let id = default_font_resolver(font, db).or_else(|| {
let sans_query = usvg::fontdb::Query {
families: &[usvg::fontdb::Family::SansSerif],
..Default::default()
};
db.query(&sans_query)
.or_else(|| db.faces().next().map(|f| f.id))
})?;
Some(fontdb.lock().owned_face(db, id))
}
});
let default_fallback_selection = usvg::FontResolver::default_fallback_selector();
let fallback_selection = Box::new(
move |ch: char, fonts: &[usvg::fontdb::ID], db: &mut Arc<usvg::fontdb::Database>| {
let mut select = |fonts: &[usvg::fontdb::ID]| {
if is_emoji_presentation(ch) {
if let Some(id) =
select_emoji_font(ch, fonts, db.as_ref(), EMOJI_FONT_FAMILIES)
{
return Some(id);
}
}
default_fallback_selection(ch, fonts, db)
};
let Some(fontdb) = enriched_fontdb.get() else {
return select(fonts);
};
let face = cached_fallback_face(fontdb, ch, fonts, select)?;
let owned_face = fontdb.lock().owned_face(db, face);
Some(if fonts.contains(&owned_face) {
face
} else {
owned_face
})
},
);
let options = usvg::Options {
font_resolver: usvg::FontResolver {
select_font: font_resolver,
select_fallback: fallback_selection,
},
..Default::default()
};
Self {
asset_source,
usvg_options: Arc::new(options),
}
}
pub fn parse_svg(&self, bytes: &[u8]) -> Result<ParsedSvg, usvg::Error> {
usvg::Tree::from_data(bytes, &self.usvg_options).map(ParsedSvg)
}
pub fn measure_text_width(
&self,
text: &str,
font: &SvgTextFont<'_>,
) -> Result<f32, usvg::Error> {
let mut svg = String::from(
r#"<svg xmlns="http://www.w3.org/2000/svg"><text xml:space="preserve" text-decoration="underline" font-family=""#,
);
push_xml_escaped(&mut svg, font.family);
svg.push_str(r#"" font-weight=""#);
push_xml_escaped(&mut svg, font.weight);
svg.push_str(r#"" font-style=""#);
push_xml_escaped(&mut svg, font.style);
let size = font.size;
svg.push_str(&format!(r#"" font-size="{size}">"#));
push_xml_escaped(&mut svg, text);
svg.push_str("</text></svg>");
let tree = usvg::Tree::from_str(&svg, &self.usvg_options)?;
Ok(underline_width(tree.root()))
}
pub fn render_parsed(
&self,
svg: &ParsedSvg,
size: impl Into<SvgSize>,
) -> Result<Arc<RenderImage>, usvg::Error> {
let (size, image_scale_factor) = match size.into() {
SvgSize::Size(size) => (SvgSize::Size(size), 1.0),
SvgSize::ExactSize(size) => (SvgSize::ExactSize(size), 1.0),
SvgSize::ScaleFactor(scale_factor) => (
SvgSize::ScaleFactor(scale_factor * SMOOTH_SVG_SCALE_FACTOR),
SMOOTH_SVG_SCALE_FACTOR,
),
};
let pixmap = rasterize_tree(&svg.0, size)?;
let mut buffer =
image::ImageBuffer::from_raw(pixmap.width(), pixmap.height(), pixmap.take()).unwrap();
for pixel in buffer.chunks_exact_mut(4) {
swap_rgba_pa_to_bgra(pixel);
}
let mut image = RenderImage::new(SmallVec::from_const([Frame::new(buffer)]));
image.scale_factor = image_scale_factor;
Ok(Arc::new(image))
}
pub fn render_single_frame(
&self,
bytes: &[u8],
scale_factor: f32,
) -> Result<Arc<RenderImage>, usvg::Error> {
let svg = self.parse_svg(bytes)?;
self.render_parsed(&svg, scale_factor)
}
pub(crate) fn render_alpha_mask(
&self,
params: &RenderSvgParams,
bytes: Option<&[u8]>,
) -> Result<Option<(Size<DevicePixels>, Vec<u8>)>> {
anyhow::ensure!(!params.size.is_zero(), "can't render at a zero size");
let render_pixmap = |bytes| {
let pixmap = self.render_pixmap(bytes, SvgSize::Size(params.size))?;
let size = Size::new(
DevicePixels(pixmap.width() as i32),
DevicePixels(pixmap.height() as i32),
);
let alpha_mask = pixmap
.pixels()
.iter()
.map(|p| p.alpha())
.collect::<Vec<_>>();
Ok(Some((size, alpha_mask)))
};
if let Some(bytes) = bytes {
render_pixmap(bytes)
} else if let Some(bytes) = self.asset_source.load(¶ms.path)? {
render_pixmap(&bytes)
} else {
Ok(None)
}
}
fn render_pixmap(&self, bytes: &[u8], size: SvgSize) -> Result<Pixmap, usvg::Error> {
let tree = usvg::Tree::from_data(bytes, &self.usvg_options)?;
rasterize_tree(&tree, size)
}
}
fn rasterize_tree(tree: &usvg::Tree, size: SvgSize) -> Result<Pixmap, usvg::Error> {
const MAX_SIZE: f32 = 8192.0;
let svg_size = tree.size();
let (mut width, mut height) = match size {
SvgSize::Size(size) => {
let scale = i32::from(size.width) as f32 / svg_size.width();
(svg_size.width() * scale, svg_size.height() * scale)
}
SvgSize::ExactSize(size) => (i32::from(size.width) as f32, i32::from(size.height) as f32),
SvgSize::ScaleFactor(scale) => (svg_size.width() * scale, svg_size.height() * scale),
};
if width > MAX_SIZE {
log::warn!("Attempted to render pixmap where width ({width}) > MAX_SIZE ({MAX_SIZE})");
}
if height > MAX_SIZE {
log::warn!("Attempted to render pixmap where height ({height}) > MAX_SIZE ({MAX_SIZE})");
}
let scale = (MAX_SIZE / width).min(MAX_SIZE / height).min(1.0);
width *= scale;
height *= scale;
let mut pixmap = resvg::tiny_skia::Pixmap::new(width as u32, height as u32)
.ok_or(usvg::Error::InvalidSize)?;
let transform = resvg::tiny_skia::Transform::from_scale(
width / svg_size.width(),
height / svg_size.height(),
);
resvg::render(tree, transform, &mut pixmap.as_mut());
Ok(pixmap)
}
const MAX_OWNED_FONT_BYTES: u64 = 64 * 1024 * 1024;
struct FontDatabase {
database: Arc<usvg::fontdb::Database>,
owned_faces: HashMap<usvg::fontdb::ID, usvg::fontdb::ID>,
remaining_owned_bytes: u64,
fallback_faces: HashMap<(usvg::fontdb::ID, char), Option<usvg::fontdb::ID>>,
}
impl FontDatabase {
fn owned_face(
&mut self,
db: &mut Arc<usvg::fontdb::Database>,
id: usvg::fontdb::ID,
) -> usvg::fontdb::ID {
let Some(usvg::fontdb::Source::File(path)) = db.face(id).map(|face| face.source.clone())
else {
return id;
};
if !self.owned_faces.contains_key(&id) {
self.own_font_file(&path);
}
*db = self.database.clone();
self.owned_faces.get(&id).copied().unwrap_or(id)
}
fn own_font_file(&mut self, path: &Path) {
let file_faces = self
.database
.faces()
.filter(|face| {
matches!(&face.source, usvg::fontdb::Source::File(face_path) if face_path == path)
})
.map(|face| (face.id, face.index))
.collect::<Vec<_>>();
let remaining_owned_bytes = self.remaining_owned_bytes;
let data = std::fs::metadata(path).and_then(|metadata| {
(metadata.len() <= remaining_owned_bytes)
.then(|| std::fs::read(path))
.transpose()
});
let owned_ids = match data {
Ok(Some(data)) if data.len() as u64 <= remaining_owned_bytes => {
let size = data.len() as u64;
let owned_ids = Arc::make_mut(&mut self.database)
.load_font_source(usvg::fontdb::Source::Binary(Arc::new(data)));
if !owned_ids.is_empty() {
self.remaining_owned_bytes -= size;
}
owned_ids
}
Ok(_) => Default::default(),
Err(error) => {
log::warn!("Failed to read font {path:?}: {error}");
Default::default()
}
};
for (id, index) in file_faces {
let owned_id = owned_ids
.iter()
.copied()
.find(|owned_id| {
self.database
.face(*owned_id)
.is_some_and(|face| face.index == index)
})
.unwrap_or(id);
self.owned_faces.insert(id, owned_id);
}
}
}
const MAX_CACHED_FALLBACK_FACES: usize = 16 * 1024;
fn cached_fallback_face(
fontdb: &Mutex<FontDatabase>,
ch: char,
fonts: &[usvg::fontdb::ID],
mut select: impl FnMut(&[usvg::fontdb::ID]) -> Option<usvg::fontdb::ID>,
) -> Option<usvg::fontdb::ID> {
let Some(base) = fonts.first() else {
return select(fonts);
};
let key = (*base, ch);
let cached_face = fontdb.lock().fallback_faces.get(&key).copied();
let face = match cached_face {
Some(face) => face,
None => {
let face = select(&fonts[..1]);
let fallback_faces = &mut fontdb.lock().fallback_faces;
if fallback_faces.len() < MAX_CACHED_FALLBACK_FACES {
fallback_faces.insert(key, face);
}
face
}
};
match face {
Some(face) if fonts.contains(&face) => select(fonts),
face => face,
}
}
fn underline_width(group: &usvg::Group) -> f32 {
group.children().iter().fold(0., |width, node| {
width
+ match node {
usvg::Node::Text(text) => text
.layouted()
.iter()
.filter_map(|span| span.underline.as_ref())
.fold(0., |width, underline| {
width + underline.data().bounds().width()
}),
usvg::Node::Group(group) => underline_width(group),
usvg::Node::Path(_) | usvg::Node::Image(_) => 0.,
}
})
}
fn push_xml_escaped(xml: &mut String, text: &str) {
for character in text.chars() {
match character {
'&' => xml.push_str("&"),
'<' => xml.push_str("<"),
'>' => xml.push_str(">"),
'"' => xml.push_str("""),
'\t' | '\n' | '\r' => xml.push(character),
'\u{0}'..='\u{1f}' | '\u{fffe}' | '\u{ffff}' => {}
_ => xml.push(character),
}
}
}
fn load_bundled_fonts(asset_source: &dyn AssetSource, db: &mut usvg::fontdb::Database) {
let font_paths = [
"fonts/ibm-plex-sans/IBMPlexSans-Regular.ttf",
"fonts/lilex/Lilex-Regular.ttf",
];
for path in font_paths {
match asset_source.load(path) {
Ok(Some(data)) => db.load_font_data(data.into_owned()),
Ok(None) => log::warn!("Bundled font not found: {path}"),
Err(error) => log::warn!("Failed to load bundled font {path}: {error}"),
}
}
}
fn fix_generic_font_families(db: &mut usvg::fontdb::Database) {
use usvg::fontdb::{Family, Query};
let families_and_fallbacks: &[(Family<'_>, &str)] = &[
(Family::SansSerif, "IBM Plex Sans"),
(Family::Serif, "IBM Plex Sans"),
(Family::Monospace, "Lilex"),
(Family::Cursive, "IBM Plex Sans"),
(Family::Fantasy, "IBM Plex Sans"),
];
for (family, fallback_name) in families_and_fallbacks {
let query = Query {
families: &[*family],
..Default::default()
};
if db.query(&query).is_none() {
match family {
Family::SansSerif => db.set_sans_serif_family(*fallback_name),
Family::Serif => db.set_serif_family(*fallback_name),
Family::Monospace => db.set_monospace_family(*fallback_name),
Family::Cursive => db.set_cursive_family(*fallback_name),
Family::Fantasy => db.set_fantasy_family(*fallback_name),
_ => {}
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::{borrow::Cow, cell::Cell};
use usvg::fontdb::{Database, Family, Query};
const IBM_PLEX_REGULAR: &[u8] =
include_bytes!("../../../assets/fonts/ibm-plex-sans/IBMPlexSans-Regular.ttf");
const LILEX_REGULAR: &[u8] = include_bytes!("../../../assets/fonts/lilex/Lilex-Regular.ttf");
#[test]
fn renders_parsed_svg_at_requested_size() -> Result<()> {
let renderer = SvgRenderer::new(Arc::new(()));
let svg = renderer.parse_svg(
br#"<svg xmlns="http://www.w3.org/2000/svg" width="24pt" height="12pt"></svg>"#,
)?;
let requested_size = Size::new(DevicePixels(24), DevicePixels(12));
let image = renderer.render_parsed(&svg, SvgSize::ExactSize(requested_size))?;
assert_eq!(image.size(0), requested_size);
Ok(())
}
#[test]
fn preserves_aspect_ratio_for_width_constrained_size() -> Result<()> {
let renderer = SvgRenderer::new(Arc::new(()));
let svg = renderer.parse_svg(
br#"<svg xmlns="http://www.w3.org/2000/svg" width="24pt" height="12pt"></svg>"#,
)?;
let image = renderer.render_parsed(
&svg,
SvgSize::Size(Size::new(DevicePixels(24), DevicePixels(24))),
)?;
assert_eq!(image.size(0), Size::new(DevicePixels(24), DevicePixels(12)));
Ok(())
}
#[test]
fn measured_text_width_matches_rasterized_advance() -> Result<()> {
let renderer = SvgRenderer::new(Arc::new(BundledFonts));
let font = SvgTextFont {
family: "IBM Plex Sans",
size: 40.,
weight: "normal",
style: "normal",
};
let frame_width = rasterized_text_width(&renderer, "MM")?;
assert!(frame_width > 0.);
for text in ["MMMM", " ", " ", "\u{a0}", "\u{200b}", "M\u{200b}"] {
let measured = renderer.measure_text_width(text, &font)?;
let rasterized = rasterized_text_width(&renderer, &format!("M{text}M"))? - frame_width;
assert!(
(measured - rasterized).abs() <= 1.,
"{text:?} measured {measured}px, rasterized {rasterized}px"
);
}
assert_eq!(
renderer.measure_text_width("M\u{200b}", &font)?,
renderer.measure_text_width("M", &font)?
);
assert!(renderer.measure_text_width("<&\"\u{1}>", &font)? > 0.);
Ok(())
}
#[test]
fn owns_font_bytes_within_budget() -> Result<()> {
let font_path = |name| {
std::env::temp_dir().join(format!(
"gpui-svg-renderer-{}-{name}.ttf",
std::process::id()
))
};
let (plex_path, lilex_path) = (font_path("plex"), font_path("lilex"));
std::fs::write(&plex_path, IBM_PLEX_REGULAR)?;
std::fs::write(&lilex_path, LILEX_REGULAR)?;
let mut database = Database::new();
database.load_font_file(&plex_path)?;
database.load_font_file(&lilex_path)?;
let mut fonts = FontDatabase {
database: Arc::new(database),
owned_faces: HashMap::default(),
remaining_owned_bytes: IBM_PLEX_REGULAR.len() as u64,
fallback_faces: HashMap::default(),
};
let mut db = fonts.database.clone();
let face_ids = db.faces().map(|face| face.id).collect::<Vec<_>>();
let (plex_id, lilex_id) = (face_ids[0], face_ids[1]);
let owned_plex_id = fonts.owned_face(&mut db, plex_id);
let owned_lilex_id = fonts.owned_face(&mut db, lilex_id);
std::fs::write(&plex_path, b"changed")?;
let data_len = |id| db.with_face_data(id, |data, _| data.len());
let data_lens = (data_len(plex_id), data_len(owned_plex_id));
std::fs::remove_file(&plex_path)?;
std::fs::remove_file(&lilex_path)?;
assert_eq!(data_lens, (Some(7), Some(IBM_PLEX_REGULAR.len())));
assert_eq!(owned_lilex_id, lilex_id);
assert_eq!(fonts.remaining_owned_bytes, 0);
assert_eq!(fonts.owned_face(&mut db, plex_id), owned_plex_id);
Ok(())
}
#[test]
fn fallback_faces_are_remembered_until_excluded() {
let database = db_with_bundled_fonts();
let face_ids = database.faces().map(|face| face.id).collect::<Vec<_>>();
let (base, fallback) = (face_ids[0], face_ids[1]);
let fontdb = Mutex::new(FontDatabase {
database: Arc::new(database),
owned_faces: HashMap::default(),
remaining_owned_bytes: 0,
fallback_faces: HashMap::default(),
});
let selections = Cell::new(0);
let fallback_face = |ch, fonts: &[usvg::fontdb::ID]| {
cached_fallback_face(&fontdb, ch, fonts, |excluded| {
selections.set(selections.get() + 1);
(!excluded.contains(&fallback)).then_some(fallback)
})
};
assert_eq!(fallback_face('x', &[base]), Some(fallback));
assert_eq!(fallback_face('x', &[base]), Some(fallback));
assert_eq!(selections.get(), 1);
assert_eq!(fallback_face('x', &[base, fallback]), None);
assert_eq!(selections.get(), 2);
assert_eq!(fallback_face('y', &[base, fallback]), None);
assert_eq!(selections.get(), 4);
assert_eq!(fallback_face('y', &[base]), Some(fallback));
assert_eq!(selections.get(), 4);
}
fn db_with_bundled_fonts() -> Database {
let mut db = Database::new();
db.load_font_data(IBM_PLEX_REGULAR.to_vec());
db.load_font_data(LILEX_REGULAR.to_vec());
db
}
#[test]
fn text_with_split_glyph_clusters_in_mixed_fonts_does_not_panic() {
let mut db = Database::new();
db.load_font_data(IBM_PLEX_REGULAR.to_vec());
db.load_font_data(LILEX_REGULAR.to_vec());
let options = usvg::Options {
fontdb: std::sync::Arc::new(db),
..Default::default()
};
let zalgo = "e\u{0301}\u{0302}\u{0303}\u{0304}\u{0306}\u{0307}\u{0308}\u{030a}";
let svg = format!(
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>"#
);
usvg::Tree::from_data(svg.as_bytes(), &options)
.expect("SVG with mixed-font text should parse");
}
#[test]
fn test_is_emoji_presentation() {
let cases = [
("a", false),
("Z", false),
("1", false),
("#", false),
("*", false),
("漢", false),
("中", false),
("カ", false),
("©", false),
("♥", false),
("😀", true),
("✅", true),
("🇺🇸", true),
("©️", false),
("♥️", false),
("1️⃣", false),
];
for (s, expected) in cases {
assert_eq!(
is_emoji_presentation(s.chars().next().unwrap()),
expected,
"for char {:?}",
s
);
}
}
#[test]
fn fix_generic_font_families_sets_all_families() {
let mut db = db_with_bundled_fonts();
fix_generic_font_families(&mut db);
let families = [
Family::SansSerif,
Family::Serif,
Family::Monospace,
Family::Cursive,
Family::Fantasy,
];
for family in families {
let query = Query {
families: &[family],
..Default::default()
};
assert!(
db.query(&query).is_some(),
"Expected generic family {family:?} to resolve after fix_generic_font_families"
);
}
}
#[test]
fn test_select_emoji_font_skips_family_without_glyph() {
let db = db_with_bundled_fonts();
let ibm_plex_sans = db
.query(&usvg::fontdb::Query {
families: &[usvg::fontdb::Family::Name("IBM Plex Sans")],
weight: usvg::fontdb::Weight(400),
stretch: usvg::fontdb::Stretch::Normal,
style: usvg::fontdb::Style::Normal,
})
.unwrap();
let lilex = db
.query(&usvg::fontdb::Query {
families: &[usvg::fontdb::Family::Name("Lilex")],
weight: usvg::fontdb::Weight(400),
stretch: usvg::fontdb::Stretch::Normal,
style: usvg::fontdb::Style::Normal,
})
.unwrap();
let selected = select_emoji_font('│', &[], &db, &["IBM Plex Sans", "Lilex"]).unwrap();
assert_eq!(selected, lilex);
assert!(!font_has_char(&db, ibm_plex_sans, '│'));
assert!(font_has_char(&db, selected, '│'));
}
#[test]
fn fix_generic_font_families_monospace_resolves_to_lilex() {
let mut db = db_with_bundled_fonts();
fix_generic_font_families(&mut db);
let query = Query {
families: &[Family::Monospace],
..Default::default()
};
let id = db.query(&query).expect("Monospace should resolve");
let face = db.face(id).expect("Face should exist");
assert!(
face.families.iter().any(|(name, _)| name.contains("Lilex")),
"Monospace should map to Lilex, got {:?}",
face.families
);
}
struct BundledFonts;
impl AssetSource for BundledFonts {
fn load(&self, path: &str) -> Result<Option<Cow<'static, [u8]>>> {
Ok(match path {
"fonts/ibm-plex-sans/IBMPlexSans-Regular.ttf" => {
Some(Cow::Borrowed(IBM_PLEX_REGULAR))
}
"fonts/lilex/Lilex-Regular.ttf" => Some(Cow::Borrowed(LILEX_REGULAR)),
_ => None,
})
}
fn list(&self, _path: &str) -> Result<Vec<SharedString>> {
Ok(Vec::new())
}
}
fn rasterized_text_width(renderer: &SvgRenderer, text: &str) -> Result<f32> {
let svg = format!(
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>"#
);
let pixmap = renderer.render_pixmap(svg.as_bytes(), SvgSize::ScaleFactor(1.))?;
let width = pixmap.width() as usize;
let inked_columns = (0..width)
.filter(|column| {
pixmap
.pixels()
.iter()
.skip(*column)
.step_by(width)
.any(|pixel| pixel.alpha() > 0)
})
.collect::<Vec<_>>();
Ok(match (inked_columns.first(), inked_columns.last()) {
(Some(first), Some(last)) => (last - first + 1) as f32,
_ => 0.,
})
}
}