fontique: Update to objc2 0.6 and new CoreFoundation bindings

The `objc2` family of crates now provides bindings for CoreFoundation
and CoreText (and much more), so we can use these rather than the
old `core-foundation` and `core-text` crates.

This also simplifies some of the code. One simplification assumes
that `CTFontCreateUIFontForLanguage` won't fail.

Author: waywardmonkeys

Cargo.lock

@@ -25,7 +25,7 @@ unicode_script = ["dep:unicode-script"]
 system = [
 	"std",
 	"dep:windows", "dep:windows-core",
-	"dep:core-text", "dep:core-foundation", "dep:objc2", "dep:objc2-foundation",
+	"dep:objc2-core-text", "dep:objc2-core-foundation", "dep:objc2-foundation",
 	"dep:fontconfig-cache-parser", "dep:roxmltree",
 ]
 
@@ -46,10 +46,9 @@ windows = { version = "0.58.0", features = ["implement", "Win32_Graphics_DirectW
 windows-core = { version = "0.58", optional = true }
 
 [target.'cfg(target_vendor = "apple")'.dependencies]
-core-text = { version = "20.1.0", optional = true }
-core-foundation = { version = "0.9.4", optional = true }
-objc2 = { version = "0.5.2", optional = true }
-objc2-foundation = { version = "0.2.2", features = ["NSArray", "NSEnumerator", "NSPathUtilities", "NSString"], optional = true }
+objc2-foundation = { version = "0.3.0", optional = true, default-features = false, features = ["alloc", "NSArray", "NSEnumerator", "NSPathUtilities", "NSString"] }
+objc2-core-foundation = { version = "0.3.0", optional = true, default-features = false, features = ["CFBase"]  }
+objc2-core-text = { version = "0.3.0", optional = true, default-features = false, features = ["CTFont", "CTFontDescriptor"] }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 fontconfig-cache-parser = { version = "0.2.0", optional = true }

fontique/Cargo.toml

@@ -5,22 +5,17 @@ use super::{
     scan, FallbackKey, FamilyId, FamilyInfo, FamilyNameMap, GenericFamily, GenericFamilyMap,
 };
 use alloc::sync::Arc;
+use core::ptr::{null, null_mut};
 use hashbrown::HashMap;
-use objc2::runtime::Bool;
+use objc2_core_foundation::{CFDictionaryCreate, CFRange, CFRetained, CFString, CFStringGetLength};
+use objc2_core_text::{
+    CTFont, CTFontCopyFamilyName, CTFontCreateForString, CTFontCreateForStringWithLanguage,
+    CTFontCreateUIFontForLanguage, CTFontCreateWithFontDescriptor,
+    CTFontDescriptorCreateWithAttributes, CTFontUIFontType,
+};
 use objc2_foundation::{
     NSSearchPathDirectory, NSSearchPathDomainMask, NSSearchPathForDirectoriesInDomains,
 };
-use {
-    core_foundation::{
-        base::{CFRange, TCFType},
-        dictionary::CFDictionary,
-        string::{CFString, CFStringRef},
-    },
-    core_text::{
-        font::{self, kCTFontSystemFontType, CTFont, CTFontRef, CTFontUIFontType},
-        font_descriptor,
-    },
-};
 
 const DEFAULT_GENERIC_FAMILIES: &[(GenericFamily, &[&str])] = &[
     (GenericFamily::Serif, &["Times", "Times New Roman"]),
@@ -43,12 +38,11 @@ impl SystemFonts {
     pub(crate) fn new() -> Self {
         let paths = unsafe {
             NSSearchPathForDirectoriesInDomains(
-                NSSearchPathDirectory::NSLibraryDirectory,
-                NSSearchPathDomainMask::NSAllDomainsMask,
-                Bool::YES,
+                NSSearchPathDirectory::LibraryDirectory,
+                NSSearchPathDomainMask::AllDomainsMask,
+                true,
             )
-            .as_ref()
-            .iter()
+            .into_iter()
             .map(|p| format!("{p}/Fonts/"))
         };
         let scanned = scan::ScannedCollection::from_paths(paths, 8);
@@ -77,97 +71,39 @@ impl SystemFonts {
     pub(crate) fn fallback(&mut self, key: impl Into<FallbackKey>) -> Option<FamilyId> {
         let key = key.into();
         let sample = key.script().sample()?;
-        self.fallback_for_text(sample, key.locale(), false)
+        let font = self.fallback_font_for_text(sample, key.locale(), false)?;
+        let family_name = unsafe { CTFontCopyFamilyName(&font) };
+        self.name_map.get(&family_name.to_string()).map(|n| n.id())
     }
-}
 
-impl SystemFonts {
-    fn fallback_for_text(
+    fn fallback_font_for_text(
         &mut self,
         text: &str,
         locale: Option<&str>,
         prefer_ui: bool,
-    ) -> Option<FamilyId> {
-        let font = fallback_for_text(text, locale, prefer_ui)?;
-        self.name_map.get(&font.family_name()).map(|n| n.id())
-    }
-}
-
-fn fallback_for_text(text: &str, locale: Option<&str>, prefer_ui: bool) -> Option<CTFont> {
-    let cf_text = CFString::new(text);
-    let cf_text_range = CFRange::init(0, cf_text.char_len());
-    let cf_locale = locale.map(CFString::new);
-    let base_font = {
-        let desc_attrs = CFDictionary::from_CFType_pairs(&[]);
-        let mut desc = font_descriptor::new_from_attributes(&desc_attrs);
-        if prefer_ui {
-            if let Some(ui_desc) = ui_font_for_language(kCTFontSystemFontType, 0.0, None)
-                .map(|font| font.copy_descriptor())
-            {
-                desc = ui_desc;
-            }
-        }
-        font::new_from_descriptor(&desc, 0.0)
-    };
-    let font = unsafe {
-        CTFont::wrap_under_create_rule(if let Some(locale) = cf_locale {
-            CTFontCreateForStringWithLanguage(
-                base_font.as_concrete_TypeRef(),
-                cf_text.as_concrete_TypeRef(),
-                cf_text_range,
-                locale.as_concrete_TypeRef(),
-            )
-        } else {
-            CTFontCreateForString(
-                base_font.as_concrete_TypeRef(),
-                cf_text.as_concrete_TypeRef(),
-                cf_text_range,
-            )
-        })
-    };
-    Some(font)
-}
-
-fn ui_font_for_language(
-    ui_type: CTFontUIFontType,
-    size: f64,
-    language: Option<CFString>,
-) -> Option<CTFont> {
-    unsafe {
-        let font_ref = CTFontCreateUIFontForLanguage(
-            ui_type,
-            size,
-            language
-                .as_ref()
-                .map(|x| x.as_concrete_TypeRef())
-                .unwrap_or(std::ptr::null()),
-        );
-        if font_ref.is_null() {
-            None
+    ) -> Option<CFRetained<CTFont>> {
+        let text = CFString::from_str(text);
+        let text_range = CFRange {
+            location: 0,
+            length: unsafe { CFStringGetLength(&text) },
+        };
+        let locale = locale.map(CFString::from_str);
+        let base_font = if prefer_ui {
+            unsafe { CTFontCreateUIFontForLanguage(CTFontUIFontType::System, 0.0, None).unwrap() }
         } else {
-            Some(CTFont::wrap_under_create_rule(font_ref))
-        }
+            unsafe {
+                let attrs = CFDictionaryCreate(None, null_mut(), null_mut(), 0, null(), null());
+                let desc = CTFontDescriptorCreateWithAttributes(&attrs.unwrap());
+                CTFontCreateWithFontDescriptor(&desc, 0.0, null())
+            }
+        };
+        let font = unsafe {
+            if let Some(locale) = locale {
+                CTFontCreateForStringWithLanguage(&base_font, &text, text_range, Some(&locale))
+            } else {
+                CTFontCreateForString(&base_font, &text, text_range)
+            }
+        };
+        Some(font)
     }
 }
-
-#[link(name = "CoreText", kind = "framework")]
-extern "C" {
-    fn CTFontCreateUIFontForLanguage(
-        uiType: CTFontUIFontType,
-        size: f64,
-        language: CFStringRef,
-    ) -> CTFontRef;
-
-    fn CTFontCreateForString(
-        currentFont: CTFontRef,
-        string: CFStringRef,
-        range: CFRange,
-    ) -> CTFontRef;
-
-    fn CTFontCreateForStringWithLanguage(
-        currentFont: CTFontRef,
-        string: CFStringRef,
-        range: CFRange,
-        language: CFStringRef,
-    ) -> CTFontRef;
-}