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, 380 insertions, 0 deletions

diff --git a/font/src/darwin/mod.rs b/font/src/darwin/mod.rs
new file mode 100644
index 00000000..844850e0
--- /dev/null
+++ b/font/src/darwin/mod.rs
@@ -0,0 +1,380 @@
+//! Font rendering based on CoreText
+//!
+//! TODO error handling... just search for unwrap.
+use std::collections::HashMap;
+use std::ops::Deref;
+use std::ptr;
+
+use core_foundation::base::TCFType;
+use core_foundation::string::{CFString, CFStringRef};
+use core_foundation::array::CFIndex;
+use core_foundation_sys::string::UniChar;
+use core_graphics::base::kCGImageAlphaNoneSkipFirst;
+use core_graphics::base::kCGImageAlphaPremultipliedLast;
+use core_graphics::color_space::CGColorSpace;
+use core_graphics::context::{CGContext, CGContextRef};
+use core_graphics::font::CGGlyph;
+use core_graphics::geometry::CGPoint;
+use core_text::font::{CTFont, new_from_descriptor as ct_new_from_descriptor};
+use core_text::font_collection::create_for_family;
+use core_text::font_collection::get_family_names as ct_get_family_names;
+use core_text::font_descriptor::kCTFontDefaultOrientation;
+use core_text::font_descriptor::kCTFontHorizontalOrientation;
+use core_text::font_descriptor::kCTFontVerticalOrientation;
+use core_text::font_descriptor::{CTFontDescriptor, CTFontDescriptorRef, CTFontOrientation};
+
+use euclid::point::Point2D;
+use euclid::rect::Rect;
+use euclid::size::Size2D;
+
+use super::{FontDesc, RasterizedGlyph, Metrics};
+
+/// Font descriptor
+///
+/// The descriptor provides data about a font and supports creating a font.
+#[derive(Debug)]
+pub struct Descriptor {
+    family_name: String,
+    font_name: String,
+    style_name: String,
+    display_name: String,
+    font_path: String,
+
+    ct_descriptor: CTFontDescriptor
+}
+
+/// Rasterizer, the main type exported by this package
+///
+/// Given a fontdesc, can rasterize fonts.
+pub struct Rasterizer {
+    fonts: HashMap<FontDesc, Font>,
+    device_pixel_ratio: f32,
+}
+
+impl Rasterizer {
+    pub fn new(dpi_x: f32, dpi_y: f32, device_pixel_ratio: f32) -> Rasterizer {
+        println!("device_pixel_ratio: {}", device_pixel_ratio);
+        Rasterizer {
+            fonts: HashMap::new(),
+            device_pixel_ratio: device_pixel_ratio,
+        }
+    }
+
+    pub fn metrics(&mut self, desc: &FontDesc, size: f32) -> Metrics {
+        let scaled_size = self.device_pixel_ratio * size;
+        self.get_font(desc, scaled_size).unwrap().metrics()
+    }
+
+    fn get_font(&mut self, desc: &FontDesc, size: f32) -> Option<Font> {
+        if let Some(font) = self.fonts.get(desc) {
+            return Some(font.clone());
+        }
+
+        let descriptors = descriptors_for_family(&desc.name[..]);
+        for descriptor in descriptors {
+            if descriptor.style_name == desc.style {
+                // Found the font we want
+                let font = descriptor.to_font(size as _);
+                self.fonts.insert(desc.to_owned(), font.clone());
+                return Some(font);
+            }
+        }
+
+        None
+    }
+
+    pub fn get_glyph(&mut self, desc: &FontDesc, size: f32, c: char) -> RasterizedGlyph {
+        let scaled_size = self.device_pixel_ratio * size;
+        let glyph = self.get_font(desc, scaled_size).unwrap().get_glyph(c, scaled_size as _);
+
+        glyph
+    }
+}
+
+/// Specifies the intended rendering orientation of the font for obtaining glyph metrics
+#[derive(Debug)]
+pub enum FontOrientation {
+    Default = kCTFontDefaultOrientation as isize,
+    Horizontal = kCTFontHorizontalOrientation as isize,
+    Vertical = kCTFontVerticalOrientation as isize,
+}
+
+impl Default for FontOrientation {
+    fn default() -> FontOrientation {
+        FontOrientation::Default
+    }
+}
+
+/// A font
+#[derive(Debug, Clone)]
+pub struct Font {
+    ct_font: CTFont
+}
+
+unsafe impl Send for Font {}
+
+/// List all family names
+pub fn get_family_names() -> Vec<String> {
+    // CFArray of CFStringRef
+    let names = ct_get_family_names();
+    let mut owned_names = Vec::new();
+
+    for name in names.iter() {
+        let family: CFString = unsafe { TCFType::wrap_under_get_rule(name as CFStringRef) };
+        owned_names.push(format!("{}", family));
+    }
+
+    owned_names
+}
+
+/// Get descriptors for family name
+pub fn descriptors_for_family(family: &str) -> Vec<Descriptor> {
+    let mut out = Vec::new();
+
+    let ct_collection = match create_for_family(family) {
+        Some(c) => c,
+        None => return out,
+    };
+
+    // CFArray of CTFontDescriptorRef (i think)
+    let descriptors = ct_collection.get_descriptors();
+    for descriptor in descriptors.iter() {
+        let desc: CTFontDescriptor = unsafe {
+            TCFType::wrap_under_get_rule(descriptor as CTFontDescriptorRef)
+        };
+        out.push(Descriptor {
+            family_name: desc.family_name(),
+            font_name: desc.font_name(),
+            style_name: desc.style_name(),
+            display_name: desc.display_name(),
+            font_path: desc.font_path(),
+            ct_descriptor: desc,
+        });
+    }
+
+    out
+}
+
+impl Descriptor {
+    /// Create a Font from this descriptor
+    pub fn to_font(&self, pt_size: f64) -> Font {
+        let ct_font = ct_new_from_descriptor(&self.ct_descriptor, pt_size);
+        Font {
+            ct_font: ct_font
+        }
+    }
+}
+
+impl Deref for Font {
+    type Target = CTFont;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.ct_font
+    }
+}
+
+impl Font {
+    /// The the bounding rect of a glyph
+    pub fn bounding_rect_for_glyph(&self, orientation: FontOrientation, index: u32) -> Rect<f64> {
+        let cg_rect = self.ct_font.get_bounding_rects_for_glyphs(orientation as CTFontOrientation,
+                                                                 &[index as CGGlyph]);
+
+        Rect::new(
+            Point2D::new(cg_rect.origin.x, cg_rect.origin.y),
+            Size2D::new(cg_rect.size.width, cg_rect.size.height),
+        )
+    }
+
+    pub fn metrics(&self) -> Metrics {
+        let average_advance = self.glyph_advance('0');
+
+        let ascent = self.ct_font.ascent() as f64;
+        let descent = self.ct_font.descent() as f64;
+        let leading = self.ct_font.leading() as f64;
+        let line_height = (ascent + descent + leading + 0.5).floor();
+
+        Metrics {
+            average_advance: average_advance,
+            line_height: line_height,
+        }
+    }
+
+    fn glyph_advance(&self, character: char) -> f64 {
+        let index = self.glyph_index(character).unwrap();
+
+        let indices = [index as CGGlyph];
+
+        self.ct_font.get_advances_for_glyphs(FontOrientation::Default as _,
+                                             &indices[0],
+                                             ptr::null_mut(),
+                                             1)
+    }
+
+    pub fn get_glyph(&self, character: char, size: f64) -> RasterizedGlyph {
+        let glyph_index = match self.glyph_index(character) {
+            Some(i) => i,
+            None => {
+                // TODO refactor this
+                return RasterizedGlyph {
+                    c: ' ',
+                    width: 0,
+                    height: 0,
+                    top: 0,
+                    left: 0,
+                    buf: Vec::new()
+                };
+            }
+        };
+
+        let bounds = self.bounding_rect_for_glyph(Default::default(), glyph_index);
+
+        let rasterized_left = bounds.origin.x.floor() as i32;
+        let rasterized_width =
+            (bounds.origin.x - (rasterized_left as f64) + bounds.size.width).ceil() as u32;
+        let rasterized_descent = (-bounds.origin.y).ceil() as i32;
+        let rasterized_ascent = (bounds.size.height + bounds.origin.y).ceil() as i32;
+        let rasterized_height = (rasterized_descent + rasterized_ascent) as u32;
+
+        if rasterized_width == 0 || rasterized_height == 0 {
+            return RasterizedGlyph {
+                c: ' ',
+                width: 0,
+                height: 0,
+                top: 0,
+                left: 0,
+                buf: Vec::new()
+            };
+        }
+
+        let mut cg_context = CGContext::create_bitmap_context(rasterized_width as usize,
+                                                              rasterized_height as usize,
+                                                              8, // bits per component
+                                                              rasterized_width as usize * 4,
+                                                              &CGColorSpace::create_device_rgb(),
+                                                              kCGImageAlphaNoneSkipFirst);
+
+        cg_context.set_allows_font_smoothing(true);
+        cg_context.set_should_smooth_fonts(true);
+        cg_context.set_allows_font_subpixel_quantization(true);
+        cg_context.set_should_subpixel_quantize_fonts(true);
+        cg_context.set_rgb_fill_color(1.0, 1.0, 1.0, 1.0);
+
+        let rasterization_origin = CGPoint {
+            x: -rasterized_left as f64,
+            y: rasterized_descent as f64,
+        };
+
+        self.ct_font.draw_glyphs(&[glyph_index as CGGlyph],
+                                 &[rasterization_origin],
+                                 cg_context.clone());
+
+        let rasterized_area = (rasterized_width * rasterized_height) as usize;
+        let rasterized_pixels = cg_context.data().to_vec();
+        let buf = rasterized_pixels.into_iter()
+                                   .enumerate()
+                                   .filter(|&(index, _)| (index % 4) != 0)
+                                   .map(|(_, val)| val)
+                                   .collect::<Vec<_>>();
+
+        RasterizedGlyph {
+            c: character,
+            left: rasterized_left,
+            top: (bounds.size.height + bounds.origin.y).ceil() as i32,
+            width: rasterized_width as i32,
+            height: rasterized_height as i32,
+            buf: buf,
+        }
+    }
+
+    fn glyph_index(&self, character: char) -> Option<u32> {
+        let chars = [character as UniChar];
+        let mut glyphs = [0 as CGGlyph];
+
+        let res = self.ct_font.get_glyphs_for_characters(&chars[0], &mut glyphs[0], 1 as CFIndex);
+
+        if res {
+            Some(glyphs[0] as u32)
+        } else {
+            None
+        }
+    }
+}
+
+/// Additional methods needed to render fonts for Alacritty
+///
+/// TODO upstream these into core_graphics crate
+trait CGContextExt {
+    fn set_allows_font_subpixel_quantization(&self, bool);
+    fn set_should_subpixel_quantize_fonts(&self, bool);
+}
+
+impl CGContextExt for CGContext {
+    fn set_allows_font_subpixel_quantization(&self, allows: bool) {
+        unsafe {
+            CGContextSetAllowsFontSubpixelQuantization(self.as_concrete_TypeRef(), allows);
+        }
+    }
+
+    fn set_should_subpixel_quantize_fonts(&self, should: bool) {
+        unsafe {
+            CGContextSetShouldSubpixelQuantizeFonts(self.as_concrete_TypeRef(), should);
+        }
+    }
+}
+
+#[link(name = "ApplicationServices", kind = "framework")]
+extern {
+    fn CGContextSetAllowsFontSubpixelQuantization(c: CGContextRef, allows: bool);
+    fn CGContextSetShouldSubpixelQuantizeFonts(c: CGContextRef, should: bool);
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn get_family_names() {
+        let names = super::get_family_names();
+        assert!(names.contains(&String::from("Menlo")));
+        assert!(names.contains(&String::from("Monaco")));
+    }
+
+    #[test]
+    fn get_descriptors_and_build_font() {
+        let list = super::descriptors_for_family("Menlo");
+        assert!(!list.is_empty());
+        println!("{:?}", list);
+
+        // Check to_font
+        let fonts = list.iter()
+                        .map(|desc| desc.to_font(72.))
+                        .collect::<Vec<_>>();
+
+        for font in fonts {
+            // Check deref
+            println!("family: {}", font.family_name());
+
+            // Get a glyph
+            for c in &['a', 'b', 'c', 'd'] {
+                let glyph = font.get_glyph(*c, 72.);
+
+                // Debug the glyph.. sigh
+                for row in 0..glyph.height {
+                    for col in 0..glyph.width {
+                        let index = ((glyph.width * 3 * row) + (col * 3)) as usize;
+                        let value = glyph.buf[index];
+                        let c = match value {
+                            0...50 => ' ',
+                            51...100 => '.',
+                            101...150 => '~',
+                            151...200 => '*',
+                            201...255 => '#',
+                            _ => unreachable!()
+                        };
+                        print!("{}", c);
+                    }
+                    print!("\n");
+                }
+            }
+        }
+    }
+}