Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

fix(text): make the shipped fonts win over installed ones of the same name

EtienneLescot2fc19a6d1a56
diff --git a/crates/compositor/src/text_fonts.rs b/crates/compositor/src/text_fonts.rs
index 3241b6fcd..c09a8c15e 100644
--- a/crates/compositor/src/text_fonts.rs
+++ b/crates/compositor/src/text_fonts.rs
@@ -7,10 +7,10 @@
//!
//! Les fichiers vivent dans `public/fonts`. L'app pose `OPENSCREEN_FONTS_DIR` sur leur dossier
//! avant de charger l'addon (`compositorViewService.ts`, même contrat que `ORT_DYLIB_PATH`), et
-//! chaque backend les enregistre pour ce processus seulement, sans rien installer : collection
-//! privée pour DirectWrite, portée processus pour CoreText, base `fontdb` pour cosmic-text.
-//! Sur macOS et Linux, une police installée qui porte le même nom peut passer devant la nôtre :
-//! c'est alors la même famille dans une autre version, jamais un repli.
+//! chaque backend les charge pour ce processus seulement, sans rien installer. Et nos fichiers
+//! gagnent toujours contre une police installée du même nom, sinon le rendu dépendrait encore
+//! de la machine : collection privée pour DirectWrite, descripteurs tirés des fichiers pour
+//! CoreText, faces homonymes du système retirées de la base `fontdb` pour cosmic-text.
//!
//! Sans la variable (POC, addon chargé hors de l'app), la liste est vide et le texte se dessine
//! avec les polices du système, comme avant.
diff --git a/crates/compositor/src/text_linux.rs b/crates/compositor/src/text_linux.rs
index ad96934f7..8e4c0b418 100644
--- a/crates/compositor/src/text_linux.rs
+++ b/crates/compositor/src/text_linux.rs
@@ -111,21 +111,51 @@ pub struct TextRasterizer {
swash_cache: RefCell<SwashCache>,
}
-/// Ajoute `files` (`crate::text_fonts`) a la base `fontdb` de ce rasteriseur, sans rien
-/// installer sur la machine. Un fichier illisible ne coute que sa police : le texte retombe
-/// sur celles du systeme.
-fn load_fonts(font_system: &mut FontSystem, files: &[std::path::PathBuf]) {
+/// Ajoute `files` (`crate::text_fonts`) a `db`, sans rien installer sur la machine, et
+/// retire de `db` toute autre face qui porte le nom d'une famille embarquee.
+///
+/// Le retrait est ce qui fait gagner nos fichiers. Une police installee du meme nom (Inter
+/// est courante sous Linux) passait devant la notre : `fontdb` ne documente aucune priorite
+/// entre deux faces egales, et en pratique la premiere chargee, celle du systeme, l'emportait.
+/// Le rendu dependait alors a nouveau de la machine. Sans face concurrente, il n'y a plus
+/// d'ordre dont dependre. Les autres familles du systeme restent, pour le repli des
+/// ecritures que nos polices ne couvrent pas.
+///
+/// Un fichier illisible ne coute que sa police : sa famille retombe sur celles du systeme.
+fn with_embedded_fonts(
+ mut db: cosmic_text::fontdb::Database,
+ files: &[std::path::PathBuf],
+) -> cosmic_text::fontdb::Database {
+ let before: std::collections::HashSet<_> = db.faces().map(|f| f.id).collect();
for path in files {
- if let Err(e) = font_system.db_mut().load_font_file(path) {
+ if let Err(e) = db.load_font_file(path) {
eprintln!("[text] police non chargee ({e}) : {}", path.display());
}
}
+ let shipped: std::collections::HashSet<String> = db
+ .faces()
+ .filter(|f| !before.contains(&f.id))
+ .flat_map(|f| f.families.iter().map(|(name, _)| name.to_lowercase()))
+ .collect();
+ let shadowed: Vec<_> = db
+ .faces()
+ .filter(|f| before.contains(&f.id))
+ .filter(|f| f.families.iter().any(|(name, _)| shipped.contains(&name.to_lowercase())))
+ .map(|f| f.id)
+ .collect();
+ for id in shadowed {
+ db.remove_face(id);
+ }
+ db
}
impl TextRasterizer {
pub fn new() -> Result<TextRasterizer> {
- let mut font_system = FontSystem::new();
- load_fonts(&mut font_system, &crate::text_fonts::embedded_font_files());
+ // Reconstruit le `FontSystem` sur la base modifiee, plutot que de la retoucher en
+ // place : il indexe ses faces (monospace, repli) a la construction.
+ let (locale, db) = FontSystem::new().into_locale_and_db();
+ let db = with_embedded_fonts(db, &crate::text_fonts::embedded_font_files());
+ let font_system = FontSystem::new_with_locale_and_db(locale, db);
Ok(TextRasterizer {
font_system: RefCell::new(font_system),
swash_cache: RefCell::new(SwashCache::new()),
@@ -453,10 +483,29 @@ mod tests {
/// qu'un controle peut produire, et deux familles ne se confondent jamais a l'ecran.
#[test]
fn every_shipped_family_draws_from_its_own_files() {
- use cosmic_text::fontdb::{Family, Query, Stretch, Style, Weight};
- let mut font_system = FontSystem::new();
- let files = crate::text_fonts::font_files_in(&crate::text_fonts::repo_fonts_dir());
- load_fonts(&mut font_system, &files);
+ use cosmic_text::fontdb::{Database, Family, Query, Source, Stretch, Style, Weight};
+ let repo = crate::text_fonts::repo_fonts_dir();
+ let files = crate::text_fonts::font_files_in(&repo);
+
+ // La collision : une police « installee » qui porte EXACTEMENT les memes familles,
+ // graisses et styles, chargee AVANT les notres comme `FontSystem::new` le fait des
+ // polices du systeme. Ce sont nos fichiers, copies ailleurs : seul le chemin distingue
+ // le gagnant.
+ let system =
+ std::env::temp_dir().join(format!("openscreen-sysfonts-{}", std::process::id()));
+ std::fs::create_dir_all(&system).unwrap();
+ let mut db = Database::new();
+ db.load_system_fonts();
+ for file in &files {
+ let copy = system.join(file.file_name().unwrap());
+ std::fs::copy(file, &copy).unwrap();
+ db.load_font_file(&copy).unwrap();
+ }
+ let db = with_embedded_fonts(db, &files);
+ let font_system = FontSystem::new_with_locale_and_db("en-US".into(), db);
+ std::fs::remove_dir_all(&system).ok();
+
+ let repo = std::fs::canonicalize(&repo).unwrap();
for family in crate::text_fonts::SHIPPED_FAMILIES {
for weight in [Weight::NORMAL, Weight::BOLD] {
let query = Query {
@@ -469,8 +518,17 @@ mod tests {
.db()
.query(&query)
.unwrap_or_else(|| panic!("{family} introuvable"));
+ let face = font_system.db().face(id).unwrap();
// Un vrai fichier de cette graisse, pas le regulier epaissi ou non.
- assert_eq!(font_system.db().face(id).unwrap().weight, weight, "{family}");
+ assert_eq!(face.weight, weight, "{family}");
+ // Et c'est NOTRE fichier, pas la face du systeme qui porte le meme nom.
+ let path = match &face.source {
+ Source::File(p) | Source::SharedFile(p, _) => p.clone(),
+ Source::Binary(_) => panic!("{family} : face sans fichier"),
+ };
+ let path = std::fs::canonicalize(&path).unwrap_or(path);
+ let from = path.display();
+ assert!(path.starts_with(&repo), "{family} {weight:?} tire de {from}");
}
}
diff --git a/crates/compositor/src/text_macos.rs b/crates/compositor/src/text_macos.rs
index 647c66a5e..0cfd49af5 100644
--- a/crates/compositor/src/text_macos.rs
+++ b/crates/compositor/src/text_macos.rs
@@ -142,8 +142,6 @@ const K_CT_PARAGRAPH_STYLE_SPECIFIER_ALIGNMENT: u32 = 0;
/// `CTFontSymbolicTraits` : italique / gras.
const K_CT_FONT_TRAIT_ITALIC: u32 = 1 << 0;
const K_CT_FONT_TRAIT_BOLD: u32 = 1 << 1;
-/// `kCTFontManagerScopeProcess` : la police n'existe que pour ce processus, rien n'est installé.
-const K_CT_FONT_MANAGER_SCOPE_PROCESS: u32 = 1;
#[repr(C)]
#[derive(Clone, Copy)]
@@ -183,6 +181,15 @@ extern "C" {
buf_len: CFIndex,
is_directory: u8,
) -> CFTypeRef;
+ fn CFRetain(cf: CFTypeRef) -> CFTypeRef;
+ fn CFArrayGetCount(array: CFTypeRef) -> CFIndex;
+ fn CFArrayGetValueAtIndex(array: CFTypeRef, index: CFIndex) -> CFTypeRef;
+ fn CFStringGetCString(
+ string: CFTypeRef,
+ buffer: *mut std::ffi::c_char,
+ buffer_size: CFIndex,
+ encoding: u32,
+ ) -> u8;
static kCFTypeDictionaryKeyCallBacks: c_void;
static kCFTypeDictionaryValueCallBacks: c_void;
}
@@ -240,11 +247,14 @@ extern "C" {
frame_attributes: CFTypeRef,
) -> CFTypeRef;
fn CTFrameDraw(frame: CFTypeRef, context: CFTypeRef);
- fn CTFontManagerRegisterFontsForURL(
- font_url: CFTypeRef,
- scope: u32,
- error: *mut CFTypeRef,
- ) -> bool;
+ fn CTFontManagerCreateFontDescriptorsFromURL(file_url: CFTypeRef) -> CFTypeRef;
+ fn CTFontCreateWithFontDescriptor(
+ descriptor: CFTypeRef,
+ size: CGFloat,
+ matrix: *const c_void,
+ ) -> CFTypeRef;
+ fn CTFontCopyFamilyName(font: CFTypeRef) -> CFTypeRef;
+ fn CTFontGetSymbolicTraits(font: CFTypeRef) -> u32;
static kCTFontAttributeName: CFTypeRef;
static kCTForegroundColorAttributeName: CFTypeRef;
@@ -420,47 +430,94 @@ unsafe fn cf_string(s: &str) -> Option<CFOwned> {
))
}
-/// Rend `files` (`crate::text_fonts`) visibles de CoreText pour CE processus seulement :
-/// `CTFontCreateWithName` les trouve ensuite par leur nom de famille, sans que rien ne soit
-/// installé sur la machine.
+/// Une police embarquée : sa famille, sa graisse, et le descripteur tiré DE SON FICHIER.
+struct ShippedFace {
+ family: String,
+ bold: bool,
+ descriptor: CFOwned,
+}
+
+// SAFETY : un `CTFontDescriptor` est immuable, et CoreText le déclare utilisable depuis
+// n'importe quel thread. Rien d'autre dans la structure.
+unsafe impl Send for ShippedFace {}
+unsafe impl Sync for ShippedFace {}
+
+/// Le texte d'une `CFString`, ou une chaîne vide.
+unsafe fn cf_string_text(string: CFTypeRef) -> String {
+ let mut buf = [0 as std::ffi::c_char; 256];
+ let len = buf.len() as CFIndex;
+ if CFStringGetCString(string, buf.as_mut_ptr(), len, K_CF_STRING_ENCODING_UTF8) == 0 {
+ return String::new();
+ }
+ std::ffi::CStr::from_ptr(buf.as_ptr()).to_string_lossy().into_owned()
+}
+
+/// Les faces de `files` (`crate::text_fonts`), chacune tenue par un descripteur de SON fichier.
+///
+/// Pas de résolution par nom, et c'est tout l'objet : une police installée qui porte le même
+/// nom de famille passerait devant la nôtre (un enregistrement `CTFontManager` en double est
+/// même refusé), et le rendu dépendrait à nouveau de la machine. Un descripteur tiré de l'URL
+/// désigne ce fichier et aucun autre. Rien n'est enregistré ni installé.
///
-/// Un fichier refusé ne coûte que sa police : le texte retombe sur celles du système. Un
-/// fichier déjà enregistré est refusé aussi, et reste utilisable.
-unsafe fn register_fonts(files: &[PathBuf]) {
+/// Un fichier illisible ne coûte que sa police : sa famille retombe sur `CTFontCreateWithName`.
+unsafe fn load_faces(files: &[PathBuf]) -> Vec<ShippedFace> {
use std::os::unix::ffi::OsStrExt;
+ let mut faces = Vec::new();
for path in files {
let bytes = path.as_os_str().as_bytes();
- let Some(url) = CFOwned::new(CFURLCreateFromFileSystemRepresentation(
+ let url = CFOwned::new(CFURLCreateFromFileSystemRepresentation(
std::ptr::null(),
bytes.as_ptr(),
bytes.len() as CFIndex,
0,
- )) else {
+ ));
+ let Some(descriptors) =
+ url.and_then(|url| CFOwned::new(CTFontManagerCreateFontDescriptorsFromURL(url.get())))
+ else {
+ eprintln!("[text] police non chargée : {}", path.display());
continue;
};
- let registered = CTFontManagerRegisterFontsForURL(
- url.get(),
- K_CT_FONT_MANAGER_SCOPE_PROCESS,
- std::ptr::null_mut(),
- );
- if !registered {
- eprintln!("[text] police non enregistrée (ou déjà) : {}", path.display());
+ for i in 0..CFArrayGetCount(descriptors.get()) {
+ let descriptor = CFArrayGetValueAtIndex(descriptors.get(), i);
+ let Some(probe) =
+ CFOwned::new(CTFontCreateWithFontDescriptor(descriptor, 12.0, std::ptr::null()))
+ else {
+ continue;
+ };
+ let Some(family) = CFOwned::new(CTFontCopyFamilyName(probe.get())) else {
+ continue;
+ };
+ faces.push(ShippedFace {
+ family: cf_string_text(family.get()),
+ bold: CTFontGetSymbolicTraits(probe.get()) & K_CT_FONT_TRAIT_BOLD != 0,
+ // Le tableau ne fait que prêter ses éléments : on en prend une référence.
+ descriptor: CFOwned(CFRetain(descriptor)),
+ });
}
}
+ faces
}
-/// Rastériseur de texte macOS. Pas d'état persistant : CoreText et CoreGraphics sont
-/// prêts dès le link des frameworks (côté Windows, `TextRasterizer::new` alloue les
-/// factories DirectWrite/Direct2D — d'où le `Result` conservé pour la symétrie).
-pub struct TextRasterizer;
+/// Rastériseur de texte macOS. Pas d'état propre : CoreText et CoreGraphics sont prêts dès
+/// le link des frameworks. Il ne tient que les polices embarquées, chargées une fois par
+/// processus (chaque compositeur, preview comme export, crée son rastériseur).
+pub struct TextRasterizer {
+ faces: &'static [ShippedFace],
+}
impl TextRasterizer {
pub fn new() -> Result<TextRasterizer> {
- // Une fois par processus : l'enregistrement vaut pour tout CoreText, alors que chaque
- // compositeur (preview, export) crée son rastériseur.
- static REGISTER: std::sync::Once = std::sync::Once::new();
- REGISTER.call_once(|| unsafe { register_fonts(&crate::text_fonts::embedded_font_files()) });
- Ok(TextRasterizer)
+ static FACES: std::sync::OnceLock<Vec<ShippedFace>> = std::sync::OnceLock::new();
+ let faces = FACES
+ .get_or_init(|| unsafe { load_faces(&crate::text_fonts::embedded_font_files()) });
+ Ok(TextRasterizer { faces })
+ }
+
+ /// La police de `family` à cette taille, tirée du fichier embarqué qui a la graisse
+ /// demandée. `None` pour une famille qui ne vient pas de l'app.
+ unsafe fn shipped_font(&self, family: &str, bold: bool, size: CGFloat) -> Option<CFOwned> {
+ let face = self.faces.iter().find(|f| f.family == family && f.bold == bold)?;
+ CFOwned::new(CTFontCreateWithFontDescriptor(face.descriptor.get(), size, std::ptr::null()))
}
/// Rastérise `spec` dans une `MTLTexture` BGRA8Unorm neuve (alpha prémultiplié).
@@ -548,18 +605,28 @@ impl TextRasterizer {
cf_string(&spec.content).ok_or_else(|| anyhow!("CFStringCreateWithBytes NULL"))?;
// --- police ---
- let family = cf_string(&spec.font_family);
- let base_font = CFOwned::new(CTFontCreateWithName(
- family.as_ref().map(|f| f.get()).unwrap_or(std::ptr::null()),
- spec.font_size_px.max(1.0) as CGFloat,
- std::ptr::null(),
- ))
- .ok_or_else(|| anyhow!("CTFontCreateWithName a renvoyé NULL"))?;
+ // Une famille embarquée vient de SON fichier, graisse comprise. Les autres, par nom.
+ let size = spec.font_size_px.max(1.0) as CGFloat;
+ let shipped = self.shipped_font(&spec.font_family, spec.bold, size);
+ let base_font = match shipped {
+ Some(font) => font,
+ None => {
+ let family = cf_string(&spec.font_family);
+ CFOwned::new(CTFontCreateWithName(
+ family.as_ref().map(|f| f.get()).unwrap_or(std::ptr::null()),
+ size,
+ std::ptr::null(),
+ ))
+ .ok_or_else(|| anyhow!("CTFontCreateWithName a renvoyé NULL"))?
+ }
+ };
+ let shipped = self.faces.iter().any(|f| f.family == spec.font_family);
// Gras/italique : une variante symbolique de la même famille. Si la famille n'a
// pas la variante, CoreText renvoie NULL — on garde alors la police de base
- // plutôt que d'échouer sur un détail de style.
+ // plutôt que d'échouer sur un détail de style. Le gras d'une famille embarquée est
+ // déjà son fichier gras.
let mut traits = 0u32;
- if spec.bold {
+ if spec.bold && !shipped {
traits |= K_CT_FONT_TRAIT_BOLD;
}
if spec.italic {
@@ -571,7 +638,13 @@ impl TextRasterizer {
0.0, // 0 = conserver la taille de la police source
std::ptr::null(),
traits,
- K_CT_FONT_TRAIT_BOLD | K_CT_FONT_TRAIT_ITALIC,
+ // Le masque ne touche que ce qu'on demande : l'italique d'une famille
+ // embarquée ne doit pas lui retirer son gras.
+ if shipped {
+ K_CT_FONT_TRAIT_ITALIC
+ } else {
+ K_CT_FONT_TRAIT_BOLD | K_CT_FONT_TRAIT_ITALIC
+ },
))
} else {
None
@@ -745,11 +818,17 @@ mod tests {
/// Rastérise et rend les octets BGRA, ou `None` si la machine n'a pas de device Metal.
fn raster_bgra(spec: &TextSpec) -> Option<(Vec<u8>, usize, usize)> {
+ raster_bgra_with(&TextRasterizer::new().expect("TextRasterizer::new"), spec)
+ }
+
+ fn raster_bgra_with(
+ raster: &TextRasterizer,
+ spec: &TextSpec,
+ ) -> Option<(Vec<u8>, usize, usize)> {
let Ok(gpu) = crate::d3d::Gpu::create(false) else {
eprintln!("pas de device Metal — test sauté");
return None;
};
- let raster = TextRasterizer::new().expect("TextRasterizer::new");
let tex = unsafe { raster.rasterize(&gpu, spec) }.expect("rasterize");
let (w, h) = (spec.box_px[0] as usize, spec.box_px[1] as usize);
let mut px = vec![0u8; w * h * 4];
@@ -788,59 +867,80 @@ mod tests {
#[link(name = "CoreText", kind = "framework")]
extern "C" {
- fn CTFontCopyFamilyName(font: CFTypeRef) -> CFTypeRef;
- fn CTFontGetSymbolicTraits(font: CFTypeRef) -> u32;
+ fn CTFontManagerRegisterFontsForURL(
+ font_url: CFTypeRef,
+ scope: u32,
+ error: *mut CFTypeRef,
+ ) -> bool;
+ fn CTFontCopyAttribute(font: CFTypeRef, attribute: CFTypeRef) -> CFTypeRef;
+ static kCTFontURLAttribute: CFTypeRef;
}
#[link(name = "CoreFoundation", kind = "framework")]
extern "C" {
- fn CFStringGetCString(
- string: CFTypeRef,
- buffer: *mut std::ffi::c_char,
- buffer_size: CFIndex,
- encoding: u32,
+ fn CFURLGetFileSystemRepresentation(
+ url: CFTypeRef,
+ resolve_against_base: u8,
+ buffer: *mut u8,
+ max_buf_len: CFIndex,
) -> u8;
}
- /// Le nom de famille que CoreText a réellement résolu pour `font`.
- unsafe fn family_of(font: CFTypeRef) -> String {
- let name = CFOwned::new(CTFontCopyFamilyName(font)).expect("CTFontCopyFamilyName");
- let mut buf = [0 as std::ffi::c_char; 256];
- let ok = CFStringGetCString(
- name.get(),
- buf.as_mut_ptr(),
- buf.len() as CFIndex,
- K_CF_STRING_ENCODING_UTF8,
- );
- assert_ne!(ok, 0, "CFStringGetCString");
- std::ffi::CStr::from_ptr(buf.as_ptr()).to_string_lossy().into_owned()
+ /// Le fichier d'où CoreText tire réellement `font`.
+ unsafe fn file_of(font: CFTypeRef) -> PathBuf {
+ use std::os::unix::ffi::OsStrExt;
+ let url = CFOwned::new(CTFontCopyAttribute(font, kCTFontURLAttribute)).expect("URL");
+ let mut buf = [0u8; 1024];
+ let ok = CFURLGetFileSystemRepresentation(url.get(), 1, buf.as_mut_ptr(), 1024);
+ assert_ne!(ok, 0, "CFURLGetFileSystemRepresentation");
+ let len = buf.iter().position(|b| *b == 0).unwrap();
+ let path = PathBuf::from(std::ffi::OsStr::from_bytes(&buf[..len]));
+ std::fs::canonicalize(&path).unwrap_or(path)
}
- /// Chaque famille embarquée est celle que CoreText dessine. `CTFontCreateWithName` ne
- /// renvoie jamais NULL pour un nom inconnu : il retombe en silence sur une autre police,
- /// donc seul le nom de famille RÉSOLU dit si la bonne a été prise.
+ /// Chaque famille embarquée est dessinée depuis SON fichier, même quand une police du
+ /// même nom est disponible par ailleurs. La collision est fabriquée : des copies de nos
+ /// fichiers, enregistrées pour le processus AVANT, portent exactement les mêmes noms.
+ /// Seul le chemin du fichier distingue le gagnant ; famille et graisse n'y suffisent pas.
#[test]
fn every_shipped_family_draws_from_its_own_files() {
- unsafe {
- register_fonts(&crate::text_fonts::font_files_in(&crate::text_fonts::repo_fonts_dir()));
- for family in crate::text_fonts::SHIPPED_FAMILIES {
- let name = cf_string(family).unwrap();
- let font = CFOwned::new(CTFontCreateWithName(name.get(), 40.0, std::ptr::null()))
- .unwrap();
- assert_eq!(family_of(font.get()), family);
- let traits = CTFontGetSymbolicTraits(font.get());
- assert_eq!(traits & K_CT_FONT_TRAIT_BOLD, 0, "{family} : le régulier sort gras");
- // Le réglage Gras prend un vrai fichier gras de la MÊME famille.
- let bold = CFOwned::new(CTFontCreateCopyWithSymbolicTraits(
- font.get(),
- 0.0,
+ use std::os::unix::ffi::OsStrExt;
+ let repo = std::fs::canonicalize(crate::text_fonts::repo_fonts_dir()).unwrap();
+ let files = crate::text_fonts::font_files_in(&repo);
+ let elsewhere =
+ std::env::temp_dir().join(format!("openscreen-sysfonts-{}", std::process::id()));
+ std::fs::create_dir_all(&elsewhere).unwrap();
+ let raster = unsafe {
+ for file in &files {
+ let copy = elsewhere.join(file.file_name().unwrap());
+ std::fs::copy(file, &copy).unwrap();
+ let bytes = copy.as_os_str().as_bytes();
+ let url = CFOwned::new(CFURLCreateFromFileSystemRepresentation(
std::ptr::null(),
- K_CT_FONT_TRAIT_BOLD,
- K_CT_FONT_TRAIT_BOLD | K_CT_FONT_TRAIT_ITALIC,
+ bytes.as_ptr(),
+ bytes.len() as CFIndex,
+ 0,
))
- .unwrap_or_else(|| panic!("{family} : pas de gras"));
- assert_eq!(family_of(bold.get()), family);
- assert_ne!(CTFontGetSymbolicTraits(bold.get()) & K_CT_FONT_TRAIT_BOLD, 0);
+ .unwrap();
+ // 1 = kCTFontManagerScopeProcess.
+ CTFontManagerRegisterFontsForURL(url.get(), 1, std::ptr::null_mut());
+ }
+ TextRasterizer { faces: Box::leak(load_faces(&files).into_boxed_slice()) }
+ };
+
+ for family in crate::text_fonts::SHIPPED_FAMILIES {
+ for bold in [false, true] {
+ let font = unsafe { raster.shipped_font(family, bold, 40.0) }
+ .unwrap_or_else(|| panic!("{family} (gras={bold}) non embarquée"));
+ unsafe {
+ let name = CFOwned::new(CTFontCopyFamilyName(font.get())).unwrap();
+ assert_eq!(cf_string_text(name.get()), family);
+ let traits = CTFontGetSymbolicTraits(font.get());
+ assert_eq!(traits & K_CT_FONT_TRAIT_BOLD != 0, bold, "{family} : graisse");
+ let file = file_of(font.get());
+ let from = file.display();
+ assert!(file.starts_with(&repo), "{family} (gras={bold}) tirée de {from}");
+ }
}
}
@@ -851,7 +951,7 @@ mod tests {
s.font_family = family.into();
s.font_size_px = 100.0;
s.box_px = [1600, 200];
- let Some((px, w, h)) = raster_bgra(&s) else {
+ let Some((px, w, h)) = raster_bgra_with(&raster, &s) else {
return;
};
let (x0, y0, x1, y1) = ink_bounds(&px, w, h);
diff --git a/electron/native-bridge/services/compositorViewService.test.ts b/electron/native-bridge/services/compositorViewService.test.ts
index 938fb42a7..d6b3aade7 100644
--- a/electron/native-bridge/services/compositorViewService.test.ts
+++ b/electron/native-bridge/services/compositorViewService.test.ts
@@ -318,6 +318,10 @@ describe("CompositorViewService text fonts", () => {
afterEach(() => {
if (originalResourcesPath) {
Object.defineProperty(process, "resourcesPath", originalResourcesPath);
+ } else {
+ // Absent before the test (plain Node): leaving the temp dir set would point later
+ // tests at a directory this hook is about to delete.
+ Reflect.deleteProperty(process, "resourcesPath");
}
if (originalVitePublic === undefined) {
Reflect.deleteProperty(process.env, "VITE_PUBLIC");