directwrite 0.1.4

A safe abstraction for interacting with DirectWrite, intended initially to be used with direct2d for easy text rendering.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

use error::DWResult;
use factory::Factory;
use font::Font;
use font_face::FontFace;
use font_family::FontFamily;

use std::ptr;

use winapi::shared::winerror::SUCCEEDED;
use winapi::um::dwrite::IDWriteFontCollection;
use wio::com::ComPtr;
use wio::wide::ToWide;

#[repr(C)]
#[derive(Clone)]
pub struct FontCollection {
    ptr: ComPtr<IDWriteFontCollection>,
}

impl FontCollection {
    /// Finds the font family with the specified family name and returns its index
    pub fn find_family_name(&self, family_name: &str) -> DWResult<Option<u32>> {
        unsafe {
            let family = family_name.to_wide_null();
            let mut index = 0;
            let mut exists = 0;
            let hr = self
                .ptr
                .FindFamilyName(family.as_ptr(), &mut index, &mut exists);
            if SUCCEEDED(hr) {
                Ok(if exists != 0 { Some(index) } else { None })
            } else {
                Err(hr.into())
            }
        }
    }

    pub unsafe fn from_raw(raw: *mut IDWriteFontCollection) -> Self {
        FontCollection {
            ptr: ComPtr::from_raw(raw),
        }
    }

    /// Creates a FontFamily object given a zero-based font family index
    pub fn get_font_family(&self, index: u32) -> DWResult<FontFamily> {
        unsafe {
            let mut ff = ptr::null_mut();
            let hr = self.ptr.GetFontFamily(index, &mut ff);
            if SUCCEEDED(hr) {
                Ok(FontFamily::from_raw(ff))
            } else {
                Err(hr.into())
            }
        }
    }

    /// Gets the number of font families in the collection
    pub fn get_font_family_count(&self) -> DWResult<u32> {
        unsafe { Ok(self.ptr.GetFontFamilyCount()) }
    }

    /// Gets the font object that corresponds to the same physical font as the specified font face object.
    /// The specified physical font must belong to the font collection.
    pub fn get_font_from_font_face(&self, font_face: &FontFace) -> DWResult<Font> {
        unsafe {
            let mut f = ptr::null_mut();
            let hr = self.ptr.GetFontFromFontFace(font_face.get_raw(), &mut f);
            if SUCCEEDED(hr) {
                Ok(Font::from_raw(f))
            } else {
                Err(hr.into())
            }
        }
    }

    /// Gets a FontCollection object which represents the set of installed fonts.
    pub fn get_system_font_collection(
        factory: &Factory,
        check_for_updates: bool,
    ) -> DWResult<FontCollection> {
        unsafe {
            let mut fc = ptr::null_mut();
            let check = if check_for_updates { 1 } else { 0 };
            let factory_ptr = &*(factory.get_raw());
            let hr = factory_ptr.GetSystemFontCollection(&mut fc, check);
            if SUCCEEDED(hr) {
                Ok(FontCollection::from_raw(fc))
            } else {
                Err(hr.into())
            }
        }
    }

    pub unsafe fn get_raw(&self) -> *mut IDWriteFontCollection {
        self.ptr.as_raw()
    }
}

unsafe impl Send for FontCollection {}
unsafe impl Sync for FontCollection {}