Merge pull request #5165 from harfbuzz/fontations-glyph-name

Fontations glyph name

src/fontations/Cargo.lock

@@ -59,9 +59,9 @@ dependencies = [
 
 [[package]]
 name = "read-fonts"
-version = "0.27.2"
+version = "0.27.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f004ee5c610b8beb5f33273246893ac6258ec22185a6eb8ee132bccdb904cdaa"
+checksum = "6d1cb3d8f1eff7ebef84ca77c0ef99e84e40459132a71bd678e96c6b7f0e6c1e"
 dependencies = [
  "bytemuck",
  "font-types",
@@ -69,9 +69,9 @@ dependencies = [
 
 [[package]]
 name = "skrifa"
-version = "0.28.1"
+version = "0.29.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16e7936ca3627fdb516e97aca3c8ab5103f94ae32fe5ce80a0a02edcbacb7b53"
+checksum = "1d58313d717b05488e8c8bae9b4cb34191aa6168d07430e17a2c0a12695fe735"
 dependencies = [
  "bytemuck",
  "read-fonts",

src/fontations/Cargo.toml

@@ -4,7 +4,7 @@ edition = "2021"
 
 [dependencies]
 read-fonts = "0.27"
-skrifa = "0.28"
+skrifa = "0.29.1"
 
 [lib]
 name = "harfbuzz_fontations"

src/fontations/lib.rs

@@ -3,11 +3,12 @@
 include!(concat!(env!("OUT_DIR"), "/hb.rs"));
 
 use std::alloc::{GlobalAlloc, Layout};
+use std::collections::HashMap;
 use std::mem::transmute;
 use std::os::raw::c_void;
 use std::ptr::null_mut;
 use std::sync::atomic::{AtomicPtr, Ordering};
-use std::sync::Mutex;
+use std::sync::{Mutex, OnceLock};
 
 use read_fonts::tables::cpal::ColorRecord;
 use read_fonts::TableProvider;
@@ -22,7 +23,7 @@ use skrifa::metrics::{BoundingBox, GlyphMetrics};
 use skrifa::outline::pen::OutlinePen;
 use skrifa::outline::DrawSettings;
 use skrifa::OutlineGlyphCollection;
-use skrifa::{GlyphId, MetadataProvider};
+use skrifa::{GlyphId, GlyphNames, MetadataProvider};
 
 struct MyAllocator;
 
@@ -60,6 +61,8 @@ struct FontationsData<'a> {
     char_map: Charmap<'a>,
     outline_glyphs: OutlineGlyphCollection<'a>,
     color_glyphs: ColorGlyphCollection<'a>,
+    glyph_names: GlyphNames<'a>,
+    glyph_from_names: OnceLock<HashMap<String, hb_codepoint_t>>,
 
     // Mutex for the below
     mutex: Mutex<()>,
@@ -87,6 +90,8 @@ impl FontationsData<'_> {
 
         let color_glyphs = font_ref.color_glyphs();
 
+        let glyph_names = font_ref.glyph_names();
+
         let mut data = FontationsData {
             face_blob,
             font,
@@ -94,6 +99,8 @@ impl FontationsData<'_> {
             char_map,
             outline_glyphs,
             color_glyphs,
+            glyph_names,
+            glyph_from_names: OnceLock::new(),
             mutex: Mutex::new(()),
             serial: u32::MAX,
             x_size: Size::new(0.0),
@@ -768,6 +775,64 @@ extern "C" fn _hb_fontations_paint_glyph(
     let _ = color_glyph.paint(location, &mut painter);
 }
 
+extern "C" fn _hb_fontations_glyph_name(
+    _font: *mut hb_font_t,
+    font_data: *mut ::std::os::raw::c_void,
+    glyph: hb_codepoint_t,
+    name: *mut ::std::os::raw::c_char,
+    size: ::std::os::raw::c_uint,
+    _user_data: *mut ::std::os::raw::c_void,
+) -> hb_bool_t {
+    let data = unsafe { &mut *(font_data as *mut FontationsData) };
+
+    let glyph_name = data.glyph_names.get(GlyphId::new(glyph));
+    match glyph_name {
+        None => false as hb_bool_t,
+        Some(glyph_name) => {
+            let glyph_name = glyph_name.as_str();
+            // Copy the glyph name into the buffer, up to size-1 bytes
+            let len = glyph_name.len().min(size as usize - 1);
+            unsafe {
+                std::ptr::copy_nonoverlapping(glyph_name.as_ptr(), name as *mut u8, len);
+                *name.add(len) = 0;
+            }
+            true as hb_bool_t
+        }
+    }
+}
+
+extern "C" fn _hb_fontations_glyph_from_name(
+    _font: *mut hb_font_t,
+    font_data: *mut ::std::os::raw::c_void,
+    name: *const ::std::os::raw::c_char,
+    len: ::std::os::raw::c_int,
+    glyph: *mut hb_codepoint_t,
+    _user_data: *mut ::std::os::raw::c_void,
+) -> hb_bool_t {
+    let data = unsafe { &mut *(font_data as *mut FontationsData) };
+
+    let name = unsafe { std::slice::from_raw_parts(name as *const u8, len as usize) };
+    let name = std::str::from_utf8(name).unwrap_or_default();
+
+    let glyph_from_names = data.glyph_from_names.get_or_init(|| {
+        data.glyph_names
+            .iter()
+            .map(|(gid, name)| (name.to_string(), gid.to_u32()))
+            .collect()
+    });
+    let glyph_id = glyph_from_names.get(name);
+
+    match glyph_id {
+        None => false as hb_bool_t,
+        Some(glyph_id) => {
+            unsafe {
+                *glyph = *glyph_id;
+            }
+            true as hb_bool_t
+        }
+    }
+}
+
 fn _hb_fontations_font_funcs_get() -> *mut hb_font_funcs_t {
     static static_ffuncs: AtomicPtr<hb_font_funcs_t> = AtomicPtr::new(null_mut());
 
@@ -823,6 +888,18 @@ fn _hb_fontations_font_funcs_get() -> *mut hb_font_funcs_t {
                 null_mut(),
                 None,
             );
+            hb_font_funcs_set_glyph_name_func(
+                ffuncs,
+                Some(_hb_fontations_glyph_name),
+                null_mut(),
+                None,
+            );
+            hb_font_funcs_set_glyph_from_name_func(
+                ffuncs,
+                Some(_hb_fontations_glyph_from_name),
+                null_mut(),
+                None,
+            );
         }
 
         if (static_ffuncs.compare_exchange(null_mut(), ffuncs, Ordering::SeqCst, Ordering::Relaxed))