Add mac_core library for FFI bindings to CoreFoundation/CoreText

Author: CraftSpider

Cargo.lock

@@ -53,6 +53,7 @@ members = [
     "crates/errors",
     "crates/geturl",
     "crates/io_base",
+    "crates/mac_core",
     "crates/pdf_io",
     "crates/status_base",
     "crates/xdv",

Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "tectonic_mac_core"
+license = "MIT"
+version = "0.0.0-dev.0"
+edition = "2021"
+
+[dependencies]
+libc = "0.2"
+
+[build-dependencies]
+tectonic_cfg_support = { path = "../cfg_support", version = "0.0.0-dev.0" }
+
+[package.metadata.internal_dep_versions]
+tectonic_cfg_support = "thiscommit:aeRoo7oa"

crates/mac_core/Cargo.toml

@@ -0,0 +1,13 @@
+use tectonic_cfg_support::target_cfg;
+
+fn main() {
+    let is_mac_os = target_cfg!(target_os = "macos");
+
+    if is_mac_os {
+        println!("cargo:rustc-link-lib=framework=Foundation");
+        println!("cargo:rustc-link-lib=framework=CoreFoundation");
+        println!("cargo:rustc-link-lib=framework=CoreGraphics");
+        println!("cargo:rustc-link-lib=framework=CoreText");
+        println!("cargo:rustc-link-lib=framework=AppKit");
+    }
+}

crates/mac_core/build.rs

@@ -0,0 +1,57 @@
+use super::{sys, CoreType};
+use std::marker::PhantomData;
+use std::ops::Index;
+use std::ptr;
+use std::ptr::NonNull;
+
+cfty! {
+    CFArray<T> : CFArrayGetTypeID
+}
+
+impl<T: CoreType> CFArray<T> {
+    pub fn empty() -> CFArray<T> {
+        let ptr = unsafe {
+            sys::CFArrayCreate(
+                ptr::null_mut(),
+                ptr::null_mut(),
+                0,
+                &sys::kCFTypeArrayCallBacks,
+            )
+        };
+        CFArray::new_owned(NonNull::new(ptr.cast_mut()).unwrap())
+    }
+
+    pub fn new(values: &[T]) -> CFArray<T> {
+        let ptr = unsafe {
+            sys::CFArrayCreate(
+                ptr::null_mut(),
+                values.as_ptr().cast_mut().cast(),
+                values.len() as sys::CFIndex,
+                &sys::kCFTypeArrayCallBacks,
+            )
+        };
+        CFArray::new_owned(NonNull::new(ptr.cast_mut()).unwrap())
+    }
+
+    pub fn len(&self) -> usize {
+        unsafe { sys::CFArrayGetCount(self.0.as_ptr()) as usize }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl<T: CoreType> Index<usize> for CFArray<T> {
+    type Output = T;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        let ptr =
+            unsafe { sys::CFArrayGetValueAtIndex(self.0.cast().as_ptr(), index as sys::CFIndex) }
+                .cast::<T>();
+        if ptr.is_null() {
+            panic!("Index {index} out of bounds for CFArray");
+        }
+        unsafe { &*ptr }
+    }
+}

crates/mac_core/src/array.rs

@@ -0,0 +1,91 @@
+use super::{sys, CoreType};
+use std::marker::PhantomData;
+use std::mem::MaybeUninit;
+use std::ptr::NonNull;
+use std::{mem, ptr};
+
+pub trait AsPtr {
+    fn as_ptr(&self) -> *const ();
+    #[allow(clippy::len_without_is_empty)]
+    fn len(&self) -> usize;
+}
+
+impl<T> AsPtr for Vec<T> {
+    fn as_ptr(&self) -> *const () {
+        self.as_ptr().cast()
+    }
+
+    fn len(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<T, const N: usize> AsPtr for [T; N] {
+    fn as_ptr(&self) -> *const () {
+        <[T]>::as_ptr(self).cast()
+    }
+
+    fn len(&self) -> usize {
+        N
+    }
+}
+
+pub trait Pairs {
+    type Keys: AsPtr;
+    type Values: AsPtr;
+
+    fn into_pairs(self) -> (Self::Keys, Self::Values);
+}
+
+impl<K, V, const N: usize> Pairs for [(K, V); N] {
+    type Keys = [K; N];
+    type Values = [V; N];
+
+    fn into_pairs(self) -> (Self::Keys, Self::Values) {
+        let mut keys: [MaybeUninit<K>; N] = unsafe { MaybeUninit::uninit().assume_init() };
+        let mut values: [MaybeUninit<V>; N] = unsafe { MaybeUninit::uninit().assume_init() };
+
+        for (idx, (key, val)) in self.into_iter().enumerate() {
+            keys[idx].write(key);
+            values[idx].write(val);
+        }
+
+        unsafe {
+            (
+                mem::transmute_copy::<_, [K; N]>(&keys),
+                mem::transmute_copy::<_, [V; N]>(&values),
+            )
+        }
+    }
+}
+
+impl<K, V> Pairs for Vec<(K, V)> {
+    type Keys = Vec<K>;
+    type Values = Vec<V>;
+
+    fn into_pairs(self) -> (Self::Keys, Self::Values) {
+        self.into_iter().unzip()
+    }
+}
+
+cfty! {
+    CFDictionary<K, V> : CFDictionaryGetTypeID
+}
+
+impl<K: CoreType, V: CoreType> CFDictionary<K, V> {
+    pub fn new<P: Pairs>(pairs: P) -> CFDictionary<K, V> {
+        let (keys, values) = pairs.into_pairs();
+
+        let ptr = unsafe {
+            sys::CFDictionaryCreate(
+                ptr::null_mut(),
+                keys.as_ptr().cast_mut().cast(),
+                values.as_ptr().cast_mut().cast(),
+                keys.len() as sys::CFIndex,
+                &sys::kCFTypeDictionaryKeyCallBacks,
+                &sys::kCFTypeDictionaryValueCallBacks,
+            )
+        };
+        CFDictionary::new_owned(NonNull::new(ptr.cast_mut()).unwrap())
+    }
+}

crates/mac_core/src/dict.rs

@@ -0,0 +1,85 @@
+use super::{sys, CFString, CFType, CTFontDescriptor, CoreType};
+use std::ptr;
+use std::ptr::NonNull;
+
+#[derive(Copy, Clone)]
+pub enum FontAttribute {
+    Name,
+    FamilyName,
+    DisplayName,
+    URL,
+    CascadeList,
+}
+
+impl FontAttribute {
+    pub fn to_str(self) -> CFString {
+        CFString::new_borrowed(NonNull::new(self.to_raw().cast_mut()).unwrap())
+    }
+
+    pub fn to_raw(self) -> sys::CFStringRef {
+        match self {
+            FontAttribute::Name => unsafe { sys::kCTFontNameAttribute },
+            FontAttribute::FamilyName => unsafe { sys::kCTFontFamilyNameAttribute },
+            FontAttribute::DisplayName => unsafe { sys::kCTFontDisplayNameAttribute },
+            FontAttribute::URL => unsafe { sys::kCTFontURLAttribute },
+            FontAttribute::CascadeList => unsafe { sys::kCTFontCascadeListAttribute },
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub enum FontNameKey {
+    Full,
+    Family,
+    Style,
+    PostScript,
+}
+
+impl FontNameKey {
+    pub fn to_str(self) -> CFString {
+        CFString::new_borrowed(NonNull::new(self.to_raw().cast_mut()).unwrap())
+    }
+
+    fn to_raw(self) -> sys::CFStringRef {
+        match self {
+            FontNameKey::Full => unsafe { sys::kCTFontFullNameKey },
+            FontNameKey::Family => unsafe { sys::kCTFontFamilyNameKey },
+            FontNameKey::Style => unsafe { sys::kCTFontStyleNameKey },
+            FontNameKey::PostScript => unsafe { sys::kCTFontPostScriptNameKey },
+        }
+    }
+}
+
+cfty! {
+    CTFont : CTFontGetTypeID
+}
+
+impl CTFont {
+    pub fn new_descriptor(descriptor: &CTFontDescriptor, size: f64) -> CTFont {
+        let ptr = unsafe {
+            sys::CTFontCreateWithFontDescriptor(
+                descriptor.as_type_ref(),
+                size as sys::CGFloat,
+                ptr::null_mut(),
+            )
+        };
+        CTFont::new_owned(NonNull::new(ptr.cast_mut()).unwrap())
+    }
+
+    pub fn attr(&self, attr: FontAttribute) -> Option<CFType> {
+        let ptr = unsafe { sys::CTFontCopyAttribute(self.as_type_ref(), attr.to_raw()) };
+        NonNull::new(ptr.cast_mut()).map(CFType::new_owned)
+    }
+
+    pub fn name(&self, name: FontNameKey) -> Option<CFString> {
+        let ptr = unsafe { sys::CTFontCopyName(self.as_type_ref(), name.to_raw()) };
+        NonNull::new(ptr.cast_mut()).map(CFString::new_owned)
+    }
+
+    pub fn localized_name(&self, name: FontNameKey) -> Option<CFString> {
+        let ptr = unsafe {
+            sys::CTFontCopyLocalizedName(self.as_type_ref(), name.to_raw(), ptr::null_mut())
+        };
+        NonNull::new(ptr.cast_mut()).map(CFString::new_owned)
+    }
+}

crates/mac_core/src/font.rs

@@ -0,0 +1,40 @@
+use super::{sys, CFArray, CFDictionary, CFSet, CFString, CFType, CoreType, FontAttribute};
+use std::ptr::NonNull;
+
+cfty! {
+    CTFontDescriptor : CTFontDescriptorGetTypeID
+}
+
+impl CTFontDescriptor {
+    pub fn new_with_attrs(attrs: &CFDictionary<CFString, CFType>) -> CTFontDescriptor {
+        let ptr = unsafe { sys::CTFontDescriptorCreateWithAttributes(attrs.as_type_ref()) };
+        CTFontDescriptor::new_owned(NonNull::new(ptr.cast_mut()).unwrap())
+    }
+
+    pub fn copy_with_attrs(&self, attrs: &CFDictionary<CFString, CFType>) -> CTFontDescriptor {
+        let ptr = unsafe {
+            sys::CTFontDescriptorCreateCopyWithAttributes(self.as_type_ref(), attrs.as_type_ref())
+        };
+        CTFontDescriptor::new_owned(NonNull::new(ptr.cast_mut()).unwrap())
+    }
+
+    pub fn matching_font_descriptors(
+        &self,
+        mandatory: &CFSet<CFString>,
+    ) -> CFArray<CTFontDescriptor> {
+        let ptr = unsafe {
+            sys::CTFontDescriptorCreateMatchingFontDescriptors(
+                self.as_type_ref(),
+                mandatory.as_type_ref(),
+            )
+        };
+        NonNull::new(ptr.cast_mut())
+            .map(CFArray::new_owned)
+            .unwrap_or_else(CFArray::empty)
+    }
+
+    pub fn attr(&self, attr: FontAttribute) -> Option<CFType> {
+        let ptr = unsafe { sys::CTFontDescriptorCopyAttribute(self.as_type_ref(), attr.to_raw()) };
+        NonNull::new(ptr.cast_mut()).map(CFType::new_owned)
+    }
+}