Expose bindings to the following:

* Simulations

* Informational strings

* Metrics

* Outlines

* Fetching the font corresponding to a face

Author: pcwalton

Cargo.toml

@@ -3,7 +3,7 @@ name = "dwrote"
 description = "Lightweight binding to DirectWrite."
 repository = "https://github.com/servo/dwrote-rs"
 license = "MPL-2.0"
-version = "0.4.2"
+version = "0.4.3"
 authors = ["Vladimir Vukicevic <[email protected]>"]
 
 [lib]

src/com_helpers.rs

@@ -61,7 +61,7 @@ macro_rules! implement_iunknown {
             QueryInterface: {
                 unsafe extern "system" fn QueryInterface(This: *mut IUnknown,
                                                          riid: REFIID,
-                                                         ppvObject: *mut *mut c_void) -> HRESULT {
+                                                         ppvObject: *mut *mut $crate::winapi::ctypes::c_void) -> HRESULT {
                     let this = if guid_equals!(*riid, $iuud) {
                         mem::transmute(This)
                     } else if guid_equals!(*riid, UuidOfIUnknown) {

src/font.rs

@@ -5,8 +5,12 @@
 use std::cell::UnsafeCell;
 
 use comptr::ComPtr;
-use winapi::um::dwrite::{IDWriteFontFace, IDWriteLocalizedStrings, IDWriteFont};
-use winapi::um::dwrite::IDWriteFontFamily;
+use winapi::shared::minwindef::{BOOL, FALSE, TRUE};
+use winapi::shared::winerror::S_OK;
+use winapi::um::dwrite::{DWRITE_FONT_METRICS, DWRITE_INFORMATIONAL_STRING_FULL_NAME, DWRITE_INFORMATIONAL_STRING_ID};
+use winapi::um::dwrite::{DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_CID_NAME};
+use winapi::um::dwrite::{DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_NAME, IDWriteFontFace};
+use winapi::um::dwrite::{IDWriteLocalizedStrings, IDWriteFont, IDWriteFontFamily};
 use std::mem;
 
 use super::*;
@@ -54,6 +58,12 @@ impl Font {
         }
     }
 
+    pub fn simulations(&self) -> FontSimulations {
+        unsafe {
+            mem::transmute::<u32, FontSimulations>((*self.native.get()).GetSimulations())
+        }
+    }
+
     pub fn family_name(&self) -> String {
         unsafe {
             let mut family: ComPtr<IDWriteFontFamily> = ComPtr::new();
@@ -74,6 +84,23 @@ impl Font {
         }
     }
 
+    pub fn informational_string(&self, id: InformationalStringId) -> Option<String> {
+        unsafe {
+            let mut names: ComPtr<IDWriteLocalizedStrings> = ComPtr::new();
+            let mut exists = FALSE;
+            let id = id as DWRITE_INFORMATIONAL_STRING_ID;
+            let hr = (*self.native.get()).GetInformationalStrings(id,
+                                                                  names.getter_addrefs(),
+                                                                  &mut exists);
+            assert!(hr == S_OK);
+            if exists == TRUE {
+                Some(get_locale_string(&mut names))
+            } else {
+                None
+            }
+        }
+    }
+
     pub fn create_font_face(&self) -> FontFace {
         // FIXME create_font_face should cache the FontFace and return it,
         // there's a 1:1 relationship
@@ -84,4 +111,20 @@ impl Font {
             FontFace::take(face)
         }
     }
+
+    pub fn metrics(&self) -> DWRITE_FONT_METRICS {
+        unsafe {
+            let mut metrics = mem::zeroed();
+            (*self.native.get()).GetMetrics(&mut metrics);
+            metrics
+        }
+    }
+}
+
+#[repr(u32)]
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum InformationalStringId {
+    FullName = DWRITE_INFORMATIONAL_STRING_FULL_NAME,
+    PostscriptName = DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_NAME,
+    PostscriptCidName = DWRITE_INFORMATIONAL_STRING_POSTSCRIPT_CID_NAME,
 }

src/font_collection_impl.rs

@@ -0,0 +1,157 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// A temporary custom font collection that exists solely for the face-to-font mapping to work.
+
+use std::mem;
+use std::sync::atomic::AtomicUsize;
+use winapi::ctypes::c_void;
+use winapi::shared::guiddef::REFIID;
+use winapi::shared::minwindef::{BOOL, FALSE, TRUE, ULONG};
+use winapi::shared::winerror::S_OK;
+use winapi::um::dwrite::{IDWriteFactory, IDWriteFontCollectionLoader};
+use winapi::um::dwrite::{IDWriteFontCollectionLoaderVtbl, IDWriteFontFile, IDWriteFontFileEnumerator};
+use winapi::um::dwrite::{IDWriteFontFileEnumeratorVtbl};
+use winapi::um::unknwnbase::{IUnknown, IUnknownVtbl};
+use winapi::um::winnt::HRESULT;
+
+use com_helpers::{Com, UuidOfIUnknown};
+use comptr::ComPtr;
+
+DEFINE_GUID! {
+    DWRITE_FONT_COLLECTION_LOADER_UUID,
+    0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
+}
+DEFINE_GUID! {
+    DWRITE_FONT_FILE_ENUMERATOR_UUID,
+    0x12345678, 0x1234, 0x5678, 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
+}
+
+static FONT_COLLECTION_LOADER_VTBL: IDWriteFontCollectionLoaderVtbl =
+        IDWriteFontCollectionLoaderVtbl {
+    parent: implement_iunknown!(static IDWriteFontCollectionLoader,
+                                DWRITE_FONT_COLLECTION_LOADER_UUID,
+                                FontCollectionLoaderImpl),
+    CreateEnumeratorFromKey: FontCollectionLoaderImpl_CreateEnumeratorFromKey,
+};
+
+pub struct FontCollectionLoaderImpl {
+    refcount: AtomicUsize,
+    font_file: ComPtr<IDWriteFontFile>,
+}
+
+impl Com<IDWriteFontCollectionLoader> for FontCollectionLoaderImpl {
+    type Vtbl = IDWriteFontCollectionLoaderVtbl;
+    #[inline]
+    fn vtbl() -> &'static IDWriteFontCollectionLoaderVtbl {
+        &FONT_COLLECTION_LOADER_VTBL
+    }
+}
+
+impl Com<IUnknown> for FontCollectionLoaderImpl {
+    type Vtbl = IUnknownVtbl;
+    #[inline]
+    fn vtbl() -> &'static IUnknownVtbl {
+        &FONT_COLLECTION_LOADER_VTBL.parent
+    }
+}
+
+impl FontCollectionLoaderImpl {
+    pub fn new(font_file: ComPtr<IDWriteFontFile>) -> FontCollectionLoaderImpl {
+        FontCollectionLoaderImpl {
+            refcount: AtomicUsize::new(1),
+            font_file,
+        }
+    }
+}
+
+unsafe extern "system" fn FontCollectionLoaderImpl_CreateEnumeratorFromKey(
+        this: *mut IDWriteFontCollectionLoader,
+        _: *mut IDWriteFactory,
+        _: *const c_void,
+        _: u32,
+        out_enumerator: *mut *mut IDWriteFontFileEnumerator)
+        -> HRESULT {
+    let this = FontCollectionLoaderImpl::from_interface(this);
+    let enumerator = FontFileEnumeratorImpl::new((*this).font_file.clone());
+    let enumerator = ComPtr::<IDWriteFontFileEnumerator>::from_ptr(enumerator.into_interface());
+    *out_enumerator = enumerator.as_ptr();
+    S_OK
+}
+
+struct FontFileEnumeratorImpl {
+    refcount: AtomicUsize,
+    font_file: ComPtr<IDWriteFontFile>,
+    state: FontFileEnumeratorImplState,
+}
+
+impl Com<IDWriteFontFileEnumerator> for FontFileEnumeratorImpl {
+    type Vtbl = IDWriteFontFileEnumeratorVtbl;
+    #[inline]
+    fn vtbl() -> &'static IDWriteFontFileEnumeratorVtbl {
+        &FONT_FILE_ENUMERATOR_VTBL
+    }
+}
+
+impl Com<IUnknown> for FontFileEnumeratorImpl {
+    type Vtbl = IUnknownVtbl;
+    #[inline]
+    fn vtbl() -> &'static IUnknownVtbl {
+        &FONT_FILE_ENUMERATOR_VTBL.parent
+    }
+}
+
+static FONT_FILE_ENUMERATOR_VTBL: IDWriteFontFileEnumeratorVtbl = IDWriteFontFileEnumeratorVtbl {
+    parent: implement_iunknown!(static IDWriteFontFileEnumerator,
+                                DWRITE_FONT_FILE_ENUMERATOR_UUID,
+                                FontFileEnumeratorImpl),
+    GetCurrentFontFile: FontFileEnumeratorImpl_GetCurrentFontFile,
+    MoveNext: FontFileEnumeratorImpl_MoveNext,
+};
+
+impl FontFileEnumeratorImpl {
+    pub fn new(font_file: ComPtr<IDWriteFontFile>) -> FontFileEnumeratorImpl {
+        FontFileEnumeratorImpl {
+            refcount: AtomicUsize::new(1),
+            font_file,
+            state: FontFileEnumeratorImplState::Start,
+        }
+    }
+}
+
+unsafe extern "system" fn FontFileEnumeratorImpl_GetCurrentFontFile(
+        this: *mut IDWriteFontFileEnumerator,
+        out_font_file: *mut *mut IDWriteFontFile)
+        -> HRESULT {
+    // Follow Postel's law...
+    let this = FontFileEnumeratorImpl::from_interface(this);
+    *out_font_file = (*this).font_file.clone().as_ptr();
+    S_OK
+}
+
+unsafe extern "system" fn FontFileEnumeratorImpl_MoveNext(this: *mut IDWriteFontFileEnumerator,
+                                                          has_current_file: *mut BOOL)
+                                                          -> HRESULT {
+    let this = FontFileEnumeratorImpl::from_interface(this);
+    match (*this).state {
+        FontFileEnumeratorImplState::Start => {
+            (*this).state = FontFileEnumeratorImplState::Running;
+            (*has_current_file) = TRUE;
+        }
+        FontFileEnumeratorImplState::Running => {
+            (*this).state = FontFileEnumeratorImplState::End;
+            (*has_current_file) = FALSE;
+        }
+        FontFileEnumeratorImplState::End => (*has_current_file) = FALSE,
+    }
+
+    S_OK
+}
+
+#[derive(Clone, Copy, Debug)]
+enum FontFileEnumeratorImplState {
+    Start,
+    Running,
+    End,
+}

src/font_face.rs

@@ -5,18 +5,24 @@
 use std::slice;
 use std::ptr;
 use std::cell::UnsafeCell;
-use std::mem::zeroed;
+use std::mem::{self, zeroed};
 
+use com_helpers::Com;
 use comptr::ComPtr;
+use font::Font;
+use font_collection_impl::FontCollectionLoaderImpl;
+use geometry_sink_impl::GeometrySinkImpl;
+use outline_builder::OutlineBuilder;
 use super::{FontMetrics, FontFile, DefaultDWriteRenderParams, DWriteFactory};
 
-use winapi::um::dwrite::{DWRITE_RENDERING_MODE, DWRITE_RENDERING_MODE_DEFAULT};
-use winapi::um::dwrite::{DWRITE_FONT_METRICS, DWRITE_FONT_SIMULATIONS, DWRITE_MATRIX};
-use winapi::um::dwrite::{DWRITE_GLYPH_METRICS, DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC};
-use winapi::um::dwrite::{IDWriteRenderingParams, IDWriteFontFace, IDWriteFontFile};
-use winapi::shared::minwindef::{BOOL, FALSE};
 use winapi::ctypes::c_void;
+use winapi::shared::minwindef::{BOOL, FALSE, TRUE};
+use winapi::shared::winerror::S_OK;
 use winapi::um::dcommon::DWRITE_MEASURING_MODE;
+use winapi::um::dwrite::{DWRITE_GLYPH_OFFSET, DWRITE_RENDERING_MODE, DWRITE_RENDERING_MODE_DEFAULT};
+use winapi::um::dwrite::{DWRITE_FONT_METRICS, DWRITE_FONT_SIMULATIONS, DWRITE_MATRIX};
+use winapi::um::dwrite::{DWRITE_GLYPH_METRICS, DWRITE_RENDERING_MODE_NATURAL_SYMMETRIC};
+use winapi::um::dwrite::{IDWriteFont, IDWriteFontFace, IDWriteFontFile, IDWriteRenderingParams};
 
 pub struct FontFace {
     native: UnsafeCell<ComPtr<IDWriteFontFace>>,
@@ -198,4 +204,77 @@ impl FontFace {
                                           measure_mode,
                                           DefaultDWriteRenderParams())
     }
+
+    // A convenience method to get the `IDWriteFont` object corresponding to this
+    // `IDWriteFontFace`.
+    pub fn get_font(&self) -> Font {
+        unsafe {
+            // TODO(pcwalton): Support multiple files.
+            let factory = DWriteFactory();
+            let font_files = self.get_files();
+            let collection_loader = FontCollectionLoaderImpl::new(font_files[0].as_com_ptr());
+            let collection_loader = collection_loader.into_interface();
+            assert_eq!((*factory).RegisterFontCollectionLoader(collection_loader.clone()), S_OK);
+            let mut collection = ptr::null_mut();
+            assert_eq!((*factory).CreateCustomFontCollection(collection_loader,
+                                                             ptr::null(),
+                                                             0,
+                                                             &mut collection),
+                       S_OK);
+            let mut font: ComPtr<IDWriteFont> = ComPtr::new();
+            assert_eq!((*collection).GetFontFromFontFace(self.as_ptr(), font.getter_addrefs()),
+                       S_OK);
+            Font::take(font)
+        }
+    }
+
+    pub fn get_glyph_run_outline(&self,
+                                 em_size: f32,
+                                 glyph_indices: &[u16],
+                                 glyph_advances: Option<&[f32]>,
+                                 glyph_offsets: Option<&[DWRITE_GLYPH_OFFSET]>,
+                                 is_sideways: bool,
+                                 is_right_to_left: bool,
+                                 outline_builder: Box<OutlineBuilder>) {
+        unsafe {
+            let glyph_advances = match glyph_advances {
+                None => ptr::null(),
+                Some(glyph_advances) => {
+                    assert_eq!(glyph_advances.len(), glyph_indices.len());
+                    glyph_advances.as_ptr()
+                }
+            };
+            let glyph_offsets = match glyph_offsets {
+                None => ptr::null(),
+                Some(glyph_offsets) => {
+                    assert_eq!(glyph_offsets.len(), glyph_indices.len());
+                    glyph_offsets.as_ptr()
+                }
+            };
+            let is_sideways = if is_sideways { TRUE } else { FALSE };
+            let is_right_to_left = if is_right_to_left { TRUE } else { FALSE };
+            let geometry_sink = GeometrySinkImpl::new(outline_builder);
+            let geometry_sink = geometry_sink.into_interface();
+            let hr = (*self.native.get()).GetGlyphRunOutline(em_size,
+                                                            glyph_indices.as_ptr(),
+                                                            glyph_advances,
+                                                            glyph_offsets,
+                                                            glyph_indices.len() as u32,
+                                                            is_sideways,
+                                                            is_right_to_left,
+                                                            geometry_sink);
+            assert_eq!(hr, S_OK);
+        }
+    }
+}
+
+impl Clone for FontFace {
+    fn clone(&self) -> FontFace {
+        unsafe {
+            FontFace {
+                native: UnsafeCell::new((*self.native.get()).clone()),
+                metrics: self.metrics,
+            }
+        }
+    }
 }

src/font_file.rs

@@ -76,8 +76,12 @@ impl FontFile {
         }
     }
 
+    pub(crate) unsafe fn as_com_ptr(&self) -> ComPtr<IDWriteFontFile> {
+        (*self.native.get()).clone()
+    }
+
     pub unsafe fn as_ptr(&self) -> *mut IDWriteFontFile {
-        (*self.native.get()).as_ptr()
+        self.as_com_ptr().as_ptr()
     }
 
     // This is a helper to read the contents of this FontFile,

src/font_file_loader_impl.rs

@@ -2,6 +2,7 @@
 
 use std::{mem, ptr};
 use std::collections::HashMap;
+use std::sync::atomic::AtomicUsize;
 use std::sync::{Mutex, atomic};
 use std::marker::Send;
 use winapi::ctypes::c_void;
@@ -133,7 +134,7 @@ const FontFileStreamVtbl: &'static IDWriteFontFileStreamVtbl = &IDWriteFontFileS
 impl FontFileStream {
     pub fn new(data: &[u8]) -> FontFileStream {
         FontFileStream {
-            refcount: atomic::ATOMIC_USIZE_INIT,
+            refcount: AtomicUsize::new(1),
             data: data.to_vec(),
         }
     }