PolytreeDE/alacritty
1
0
Fork 0
mirror of https://github.com/alacritty/alacritty.git synced 2024-11-25 14:05:41 -05:00
Code Releases Activity

Propagate font rasterizer errors

Browse source 
This allows consumers of the font crate to handle errors instead of the
library panicking.
This commit is contained in:
Joe Wilm 2016-12-31 11:17:02 -08:00
parent a00970c9a8
commit 2738969f29
5 changed files with 206 additions and 110 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

140
font/src/darwin/mod.rs
View file

@ -54,8 +54,6 @@ use self::byte_order::extract_rgb;
use super::Size;
static FONT_LOAD_ERROR: &'static str = "font specified by FontKey has been loaded";
/// Font descriptor
///
/// The descriptor provides data about a font and supports creating a font.
@ -79,71 +77,107 @@ pub struct Rasterizer {
device_pixel_ratio: f32,
}
impl Rasterizer {
pub fn new(_dpi_x: f32, _dpi_y: f32, device_pixel_ratio: f32) -> Rasterizer {
/// Errors occurring when using the core text rasterizer
#[derive(Debug)]
pub enum Error {
/// Tried to rasterize a glyph but it was not available
MissingGlyph(char),
/// Couldn't find font matching description
MissingFont(FontDesc),
/// Requested an operation with a FontKey that isn't known to the rasterizer
FontNotLoaded,
}
impl ::std::error::Error for Error {
fn description(&self) -> &str {
match *self {
Error::MissingGlyph(ref _c) => "couldn't find the requested glyph",
Error::MissingFont(ref _desc) => "couldn't find the requested font",
Error::FontNotLoaded => "tried to operate on font that hasn't been loaded",
}
}
}
impl ::std::fmt::Display for Error {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
match *self {
Error::MissingGlyph(ref c) => {
write!(f, "Glyph not found for char {:?}", c)
},
Error::MissingFont(ref desc) => {
write!(f, "Couldn't find a font with {}", desc)
},
Error::FontNotLoaded => {
f.write_str("Tried to use a font that hasn't been loaded")
}
}
}
}
impl ::Rasterize for Rasterizer {
type Err = Error;
fn new(_dpi_x: f32, _dpi_y: f32, device_pixel_ratio: f32) -> Result<Rasterizer, Error> {
println!("device_pixel_ratio: {}", device_pixel_ratio);
Rasterizer {
Ok(Rasterizer {
fonts: HashMap::new(),
keys: HashMap::new(),
device_pixel_ratio: device_pixel_ratio,
}
})
}
/// Get metrics for font specified by FontKey
///
/// # Panics
///
/// If FontKey was not generated by `load_font`, this method will panic.
pub fn metrics(&self, key: FontKey, _size: Size) -> Metrics {
fn metrics(&self, key: FontKey, _size: Size) -> Result<Metrics, Error> {
// NOTE size is not needed here since the font loaded already contains
// it. It's part of the API due to platform differences.
let font = self.fonts.get(&key).expect(FONT_LOAD_ERROR);
font.metrics()
let font = self.fonts
.get(&key)
.ok_or(Error::FontNotLoaded)?;
Ok(font.metrics())
}
pub fn load_font(&mut self, desc: &FontDesc, size: Size) -> Option<FontKey> {
fn load_font(&mut self, desc: &FontDesc, size: Size) -> Result<FontKey, Error> {
self.keys
.get(&(desc.to_owned(), size))
.map(|k| *k)
.or_else(|| {
self.get_font(desc, size)
.map(|font| {
let key = FontKey::next();
.map(|k| Ok(*k))
.unwrap_or_else(|| {
let font = self.get_font(desc, size)?;
let key = FontKey::next();
self.fonts.insert(key, font);
self.keys.insert((desc.clone(), size), key);
self.fonts.insert(key, font);
self.keys.insert((desc.clone(), size), key);
key
})
Ok(key)
})
}
fn get_font(&mut self, desc: &FontDesc, size: Size) -> Option<Font> {
/// Get rasterized glyph for given glyph key
fn get_glyph(&mut self, glyph: &GlyphKey) -> Result<RasterizedGlyph, Error> {
let scaled_size = self.device_pixel_ratio * glyph.size.as_f32_pts();
self.fonts
.get(&glyph.font_key)
.ok_or(Error::FontNotLoaded)?
.get_glyph(glyph.c, scaled_size as _)
}
}
impl Rasterizer {
fn get_font(&mut self, desc: &FontDesc, size: Size) -> Result<Font, Error> {
let descriptors = descriptors_for_family(&desc.name[..]);
for descriptor in descriptors {
if descriptor.style_name == desc.style {
// Found the font we want
let scaled_size = size.as_f32_pts() as f64 * self.device_pixel_ratio as f64;
let font = descriptor.to_font(scaled_size);
return Some(font);
return Ok(font);
}
}
None
}
/// Get rasterized glyph for given glyph key
///
/// # Panics
///
/// Panics if the FontKey specified in GlyphKey was not generated from `load_font`
pub fn get_glyph(&mut self, glyph: &GlyphKey) -> RasterizedGlyph {
let scaled_size = self.device_pixel_ratio * glyph.size.as_f32_pts();
self.fonts
.get(&glyph.font_key)
.expect(FONT_LOAD_ERROR)
.get_glyph(glyph.c, scaled_size as _)
Err(Error::MissingFont(desc.to_owned()))
}
}
@ -269,21 +303,9 @@ impl Font {
)
}
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()
};
}
};
pub fn get_glyph(&self, character: char, _size: f64) -> Result<RasterizedGlyph, Error> {
let glyph_index = self.glyph_index(character)
.ok_or(Error::MissingGlyph(character))?;
let bounds = self.bounding_rect_for_glyph(Default::default(), glyph_index);
@ -295,14 +317,14 @@ impl Font {
let rasterized_height = (rasterized_descent + rasterized_ascent) as u32;
if rasterized_width == 0 || rasterized_height == 0 {
return RasterizedGlyph {
return Ok(RasterizedGlyph {
c: ' ',
width: 0,
height: 0,
top: 0,
left: 0,
buf: Vec::new()
};
});
}
let mut cg_context = CGContext::create_bitmap_context(
@ -354,14 +376,14 @@ impl Font {
let buf = extract_rgb(rasterized_pixels);
RasterizedGlyph {
Ok(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> {

133
font/src/ft/mod.rs
View file

@ -15,9 +15,7 @@
//! Rasterization powered by FreeType and FontConfig
use std::collections::HashMap;
use freetype::Library;
use freetype::Face;
use freetype;
use freetype::{self, Library, Face};
mod list_fonts;
@ -25,7 +23,7 @@ use self::list_fonts::{Family, get_font_families};
use super::{FontDesc, RasterizedGlyph, Metrics, Size, FontKey, GlyphKey};
/// Rasterizes glyphs for a single font face.
pub struct Rasterizer {
pub struct FreeTypeRasterizer {
faces: HashMap<FontKey, Face<'static>>,
library: Library,
system_fonts: HashMap<String, Family>,
@ -40,16 +38,13 @@ 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 ::Rasterize for FreeTypeRasterizer {
type Err = Error;
impl Rasterizer {
pub fn new(dpi_x: f32, dpi_y: f32, device_pixel_ratio: f32) -> Rasterizer {
let library = Library::init().unwrap();
fn new(dpi_x: f32, dpi_y: f32, device_pixel_ratio: f32) -> Result<FreeTypeRasterizer, Error> {
let library = Library::init()?;
Rasterizer {
Ok(FreeTypeRasterizer {
system_fonts: get_font_families(),
faces: HashMap::new(),
keys: HashMap::new(),
@ -57,11 +52,13 @@ impl Rasterizer {
dpi_x: dpi_x as u32,
dpi_y: dpi_y as u32,
dpr: device_pixel_ratio,
}
})
}
pub fn metrics(&self, key: FontKey, size: Size) -> Metrics {
let face = self.faces.get(&key).unwrap();
fn metrics(&self, key: FontKey, size: Size) -> Result<Metrics, Error> {
let face = self.faces
.get(&key)
.ok_or(Error::FontNotLoaded)?;
let scale_size = self.dpr as f64 * size.as_f32_pts() as f64;
@ -72,48 +69,36 @@ impl Rasterizer {
let w_scale = w * scale_size / em_size;
let h_scale = h * scale_size / em_size;
Metrics {
Ok(Metrics {
average_advance: w_scale,
line_height: h_scale,
}
})
}
pub fn load_font(&mut self, desc: &FontDesc, _size: Size) -> Option<FontKey> {
fn load_font(&mut self, desc: &FontDesc, _size: Size) -> Result<FontKey, Error> {
self.keys
.get(&desc.to_owned())
.map(|k| *k)
.or_else(|| {
self.get_face(desc)
.map(|face| {
let key = FontKey::next();
self.faces.insert(key, face);
key
})
.map(|k| Ok(*k))
.unwrap_or_else(|| {
let face = self.get_face(desc)?;
let key = FontKey::next();
self.faces.insert(key, face);
Ok(key)
})
}
fn get_face(&mut self, desc: &FontDesc) -> Option<Face<'static>> {
self.system_fonts
.get(&desc.name[..])
.and_then(|font| font.variants().get(&desc.style[..]))
.map(|variant| {
self.library.new_face(variant.path(), variant.index())
.expect("TODO handle new_face error")
})
}
pub fn get_glyph(&mut self, glyph_key: &GlyphKey) -> RasterizedGlyph {
fn get_glyph(&mut self, glyph_key: &GlyphKey) -> Result<RasterizedGlyph, Error> {
let face = self.faces
.get(&glyph_key.font_key)
.expect("TODO handle get_face error");
.ok_or(Error::FontNotLoaded)?;
let size = glyph_key.size.as_f32_pts() * self.dpr;
let c = glyph_key.c;
face.set_char_size(to_freetype_26_6(size), 0, self.dpi_x, self.dpi_y).unwrap();
face.load_char(c as usize, freetype::face::TARGET_LIGHT).unwrap();
face.set_char_size(to_freetype_26_6(size), 0, self.dpi_x, self.dpi_y)?;
face.load_char(c as usize, freetype::face::TARGET_LIGHT)?;
let glyph = face.glyph();
glyph.render_glyph(freetype::render_mode::RenderMode::Lcd).unwrap();
glyph.render_glyph(freetype::render_mode::RenderMode::Lcd)?;
unsafe {
let ft_lib = self.library.raw();
@ -134,18 +119,80 @@ impl Rasterizer {
packed.extend_from_slice(&buf[start..stop]);
}
RasterizedGlyph {
Ok(RasterizedGlyph {
c: c,
top: glyph.bitmap_top(),
left: glyph.bitmap_left(),
width: glyph.bitmap().width() / 3,
height: glyph.bitmap().rows(),
buf: packed,
})
}
}
impl FreeTypeRasterizer {
fn get_face(&mut self, desc: &FontDesc) -> Result<Face<'static>, Error> {
self.system_fonts
.get(&desc.name[..])
.and_then(|font| font.variants().get(&desc.style[..]))
.ok_or_else(|| Error::MissingFont(desc.to_owned()))
.and_then(|variant| Ok(self.library.new_face(variant.path(), variant.index())?))
}
}
/// Errors occurring when using the freetype rasterizer
#[derive(Debug)]
pub enum Error {
/// Error occurred within the FreeType library
FreeType(freetype::Error),
/// Couldn't find font matching description
MissingFont(FontDesc),
/// Requested an operation with a FontKey that isn't known to the rasterizer
FontNotLoaded,
}
impl ::std::error::Error for Error {
fn cause(&self) -> Option<&::std::error::Error> {
match *self {
Error::FreeType(ref err) => Some(err),
_ => None,
}
}
fn description(&self) -> &str {
match *self {
Error::FreeType(ref err) => err.description(),
Error::MissingFont(ref _desc) => "couldn't find the requested font",
Error::FontNotLoaded => "tried to operate on font that hasn't been loaded",
}
}
}
unsafe impl Send for Rasterizer {}
impl ::std::fmt::Display for Error {
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
match *self {
Error::FreeType(ref err) => {
err.fmt(f)
},
Error::MissingFont(ref desc) => {
write!(f, "Couldn't find a font with {}", desc)
},
Error::FontNotLoaded => {
f.write_str("Tried to use a font that hasn't been loaded")
}
}
}
}
impl From<freetype::Error> for Error {
fn from(val: freetype::Error) -> Error {
Error::FreeType(val)
}
}
unsafe impl Send for FreeTypeRasterizer {}
#[cfg(test)]
mod tests {

26
font/src/lib.rs
View file

@ -46,7 +46,7 @@ use std::sync::atomic::{AtomicU32, ATOMIC_U32_INIT, Ordering};
#[cfg(not(target_os = "macos"))]
mod ft;
#[cfg(not(target_os = "macos"))]
pub use ft::*;
pub use ft::{FreeTypeRasterizer as Rasterizer, Error};
// If target is macos, reexport everything from darwin
#[cfg(target_os = "macos")]
@ -71,6 +71,12 @@ impl FontDesc {
}
}
impl fmt::Display for FontDesc {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "name '{}' and style '{}'", self.name, self.style)
}
}
/// Identifier for a Font for use in maps/etc
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
pub struct FontKey {
@ -156,3 +162,21 @@ pub struct Metrics {
pub average_advance: f64,
pub line_height: f64,
}
pub trait Rasterize {
/// Errors occurring in Rasterize methods
type Err: ::std::error::Error + Send + Sync + 'static;
/// Create a new Rasterize
fn new(dpi_x: f32, dpi_y: f32, device_pixel_ratio: f32) -> Result<Self, Self::Err>
where Self: Sized;
/// Get `Metrics` for the given `FontKey` and `Size`
fn metrics(&self, FontKey, Size) -> Result<Metrics, Self::Err>;
/// Load the font described by `FontDesc` and `Size`
fn load_font(&mut self, &FontDesc, Size) -> Result<FontKey, Self::Err>;
/// Rasterize the glyph described by `GlyphKey`.
fn get_glyph(&mut self, &GlyphKey) -> Result<RasterizedGlyph, Self::Err>;
}

5
src/display.rs
View file

@ -22,7 +22,7 @@ use Rgb;
use ansi::Color;
use cli;
use config::Config;
use font;
use font::{self, Rasterize};
use meter::Meter;
use renderer::{GlyphCache, QuadRenderer};
use selection::Selection;
@ -92,7 +92,8 @@ impl Display {
println!("device_pixel_ratio: {}", dpr);
let rasterizer = font::Rasterizer::new(dpi.x(), dpi.y(), dpr);
// TODO ERROR HANDLING
let rasterizer = font::Rasterizer::new(dpi.x(), dpi.y(), dpr).unwrap();
// Create renderer
let mut renderer = QuadRenderer::new(config, size);

12
src/renderer/mod.rs
View file

@ -20,7 +20,7 @@ use std::ptr;
use std::sync::mpsc;
use cgmath;
use font::{self, Rasterizer, RasterizedGlyph, FontDesc, GlyphKey, FontKey};
use font::{self, Rasterizer, Rasterize, RasterizedGlyph, FontDesc, GlyphKey, FontKey};
use gl::types::*;
use gl;
use notify::{Watcher as WatcherApi, RecommendedWatcher as Watcher, op};
@ -138,7 +138,7 @@ impl GlyphCache {
let bold = if bold_desc == regular_desc {
regular
} else {
rasterizer.load_font(&bold_desc, size).unwrap_or_else(|| regular)
rasterizer.load_font(&bold_desc, size).unwrap_or_else(|_| regular)
};
// Load italic font
@ -149,7 +149,7 @@ impl GlyphCache {
regular
} else {
rasterizer.load_font(&italic_desc, size)
.unwrap_or_else(|| regular)
.unwrap_or_else(|_| regular)
};
let mut cache = GlyphCache {
@ -181,13 +181,15 @@ impl GlyphCache {
}
pub fn font_metrics(&self) -> font::Metrics {
self.rasterizer.metrics(self.font_key, self.font_size)
// TODO ERROR HANDLING
self.rasterizer.metrics(self.font_key, self.font_size).unwrap()
}
fn load_and_cache_glyph<L>(&mut self, glyph_key: GlyphKey, loader: &mut L)
where L: LoadGlyph
{
let rasterized = self.rasterizer.get_glyph(&glyph_key);
// TODO ERROR HANDLING
let rasterized = self.rasterizer.get_glyph(&glyph_key).unwrap();
let glyph = loader.load_glyph(&rasterized);
self.cache.insert(glyph_key, glyph);
}