Add support for macOS

Alacritty now runs on macOS using CoreText for font rendering.

The font rendering subsystems were moved into a separate crate called
`font`. The font crate provides a unified (albeit limited) API which
wraps CoreText on macOS and FreeType/FontConfig on other platforms. The
unified API differed slightly from what the original Rasterizer for
freetype implemented, and it was updated accordingly.

The cell separation properties (sep_x and sep_y) are now premultiplied
into the cell width and height. They were previously passed through as
uniforms to the shaders; removing them prevents a lot of redundant work.

`libc` has some differences between Linux and macOS. `__errno_location`
is not available on macOS, and the `errno` crate was brought in to
provide a cross-platform API for dealing with errno.

Differences in `openpty` were handled by implementing a macOS specific
version. It would be worth investigating a way to unify the
implementations at some point.

A type mismatch with TIOCSCTTY was resolved with a cast.

Differences in libc::passwd struct fields were resolved by using
std::mem::uninitialized instead of zeroing the struct ourselves. This
has the benefit of being much cleaner.

The thread setup had to be changed to support both macOS and Linux.
macOS requires that events from the window be handled on the main
thread. Failure to do so will prevent the glutin window from even
showing up! For this reason, the renderer and parser were moved to their
own thread, and the input is received on the main thread. This is
essentially reverse the setup prior to this commit. Renderer
initialization (and thus font cache initialization) had to be moved to
the rendering thread as well since there's no way to make_context(null)
with glx on Linux. Trying to just call make_context a second time on the
rendering thread had resulted in a panic!.

1 files changed, 126 insertions, 0 deletions

diff --git a/font/src/ft/mod.rs b/font/src/ft/mod.rs
new file mode 100644
index 00000000..f288cda5
--- /dev/null
+++ b/font/src/ft/mod.rs
@@ -0,0 +1,126 @@
+//! Rasterization powered by FreeType and FontConfig
+use std::collections::HashMap;
+
+use freetype::Library;
+use freetype::Face;
+use freetype;
+
+mod list_fonts;
+
+use self::list_fonts::{Family, get_font_families};
+use super::{FontDesc, RasterizedGlyph, Metrics};
+
+/// Rasterizes glyphs for a single font face.
+pub struct Rasterizer {
+    faces: HashMap<FontDesc, Face<'static>>,
+    library: Library,
+    system_fonts: HashMap<String, Family>,
+    dpi_x: u32,
+    dpi_y: u32,
+    dpr: f32,
+}
+
+#[inline]
+fn to_freetype_26_6(f: f32) -> isize {
+    ((1i32 << 6) as f32 * f) as isize
+}
+
+// #[inline]
+// fn freetype_26_6_to_float(val: i64) -> f64 {
+//     val as f64 / (1i64 << 6) as f64
+// }
+
+impl Rasterizer {
+    pub fn new(dpi_x: f32, dpi_y: f32, device_pixel_ratio: f32) -> Rasterizer {
+        let library = Library::init().unwrap();
+
+        Rasterizer {
+            system_fonts: get_font_families(),
+            faces: HashMap::new(),
+            library: library,
+            dpi_x: dpi_x as u32,
+            dpi_y: dpi_y as u32,
+            dpr: device_pixel_ratio,
+        }
+    }
+
+    pub fn metrics(&mut self, desc: &FontDesc, size: f32) -> Metrics {
+        let face = self.get_face(&desc).unwrap();
+
+        let scale_size = self.dpr as f64 * size as f64;
+
+        let em_size = face.em_size() as f64;
+        let w = face.max_advance_width() as f64;
+        let h = (face.ascender() - face.descender() + face.height()) as f64;
+
+        let w_scale = w * scale_size / em_size;
+        let h_scale = h * scale_size / em_size;
+
+        Metrics {
+            average_advance: w_scale,
+            line_height: h_scale,
+        }
+    }
+
+    fn get_face(&mut self, desc: &FontDesc) -> Option<Face<'static>> {
+        if let Some(face) = self.faces.get(desc) {
+            return Some(face.clone());
+        }
+
+        if let Some(font) = self.system_fonts.get(&desc.name[..]) {
+            if let Some(variant) = font.variants().get(&desc.style[..]) {
+                let face = self.library.new_face(variant.path(), variant.index())
+                                       .expect("TODO handle new_face error");
+
+                self.faces.insert(desc.to_owned(), face);
+                return Some(self.faces.get(desc).unwrap().clone());
+            }
+        }
+
+        None
+    }
+
+    pub fn get_glyph(&mut self, desc: &FontDesc, size: f32, c: char) -> RasterizedGlyph {
+        let face = self.get_face(desc).expect("TODO handle get_face error");
+        face.set_char_size(to_freetype_26_6(size * self.dpr), 0, self.dpi_x, self.dpi_y).unwrap();
+        face.load_char(c as usize, freetype::face::TARGET_LIGHT).unwrap();
+        let glyph = face.glyph();
+        glyph.render_glyph(freetype::render_mode::RenderMode::Lcd).unwrap();
+
+        unsafe {
+            let ft_lib = self.library.raw();
+            freetype::ffi::FT_Library_SetLcdFilter(ft_lib, freetype::ffi::FT_LCD_FILTER_DEFAULT);
+        }
+
+        let bitmap = glyph.bitmap();
+        let buf = bitmap.buffer();
+        let pitch = bitmap.pitch() as usize;
+
+        let mut packed = Vec::with_capacity((bitmap.rows() * bitmap.width()) as usize);
+        for i in 0..bitmap.rows() {
+            let start = (i as usize) * pitch;
+            let stop = start + bitmap.width() as usize;
+            packed.extend_from_slice(&buf[start..stop]);
+        }
+
+        RasterizedGlyph {
+            c: c,
+            top: glyph.bitmap_top(),
+            left: glyph.bitmap_left(),
+            width: glyph.bitmap().width() / 3,
+            height: glyph.bitmap().rows(),
+            buf: packed,
+        }
+    }
+}
+
+unsafe impl Send for Rasterizer {}
+
+#[cfg(test)]
+mod tests {
+    use ::FontDesc;
+
+    fn font_desc() -> FontDesc {
+        FontDesc::new("Ubuntu Mono", "Regular")
+    }
+}