#![doc(html_root_url = "https://docs.rs/fontdb/0.5.1")]
#![warn(missing_docs)]
#![warn(missing_debug_implementations)]
#![warn(missing_copy_implementations)]
#[cfg(feature = "fs")] use std::path::{Path, PathBuf};
use std::sync::Arc;
use log::warn;
pub use ttf_parser::Width as Stretch;
#[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd, Debug)]
pub struct ID(u32);
#[derive(Debug)]
enum LoadError {
MalformedFont,
UnnamedFont,
IoError(std::io::Error),
}
impl From<std::io::Error> for LoadError {
#[inline]
fn from(e: std::io::Error) -> Self {
LoadError::IoError(e)
}
}
impl std::fmt::Display for LoadError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
LoadError::MalformedFont => write!(f, "malformed font"),
LoadError::UnnamedFont => write!(f, "font doesn't have a family name"),
LoadError::IoError(ref e) => write!(f, "{}", e),
}
}
}
#[derive(Clone, Debug)]
pub struct Database {
next_id: u32,
faces: Vec<FaceInfo>,
family_serif: Option<String>,
family_sans_serif: Option<String>,
family_cursive: Option<String>,
family_fantasy: Option<String>,
family_monospace: Option<String>,
}
impl Database {
#[inline]
pub fn new() -> Self {
Database {
next_id: 0,
faces: Vec::new(),
family_serif: None,
family_sans_serif: None,
family_cursive: None,
family_fantasy: None,
family_monospace: None,
}
}
pub fn load_font_data(&mut self, data: Vec<u8>) {
let source = Arc::new(Source::Binary(data));
let data = match &*source {
Source::Binary(ref data) => data,
#[cfg(feature = "fs")]
Source::File(_) => unreachable!(),
};
let n = ttf_parser::fonts_in_collection(&data).unwrap_or(1);
for index in 0..n {
self.next_id = self.next_id.checked_add(1).unwrap();
match parse_face_info(self.next_id, source.clone(), &data, index) {
Ok(info) => self.faces.push(info),
Err(e) => warn!("Failed to load a font face {} from data cause {}.", index, e),
}
}
}
#[cfg(feature = "fs")]
pub fn load_font_file<P: AsRef<Path>>(&mut self, path: P) -> Result<(), std::io::Error> {
let source = Arc::new(Source::File(path.as_ref().into()));
let file = std::fs::File::open(path.as_ref())?;
let data = unsafe { &memmap2::MmapOptions::new().map(&file)? };
let n = ttf_parser::fonts_in_collection(data).unwrap_or(1);
for index in 0..n {
self.next_id = self.next_id.checked_add(1).unwrap();
match parse_face_info(self.next_id, source.clone(), data, index) {
Ok(info) => self.faces.push(info),
Err(e) => {
warn!("Failed to load a font face {} from '{}' cause {}.",
index, path.as_ref().display(), e)
}
}
}
Ok(())
}
#[cfg(feature = "fs")]
pub fn load_fonts_dir<P: AsRef<Path>>(&mut self, dir: P) {
let fonts_dir = match std::fs::read_dir(dir.as_ref()) {
Ok(dir) => dir,
Err(_) => return,
};
for entry in fonts_dir {
if let Ok(entry) = entry {
let path = entry.path();
if path.is_file() {
match path.extension().and_then(|e| e.to_str()) {
Some("ttf") | Some("ttc") | Some("TTF") | Some("TTC") |
Some("otf") | Some("otc") | Some("OTF") | Some("OTC") => {
if let Err(e) = self.load_font_file(&path) {
warn!("Failed to load '{}' cause {}.", path.display(), e);
}
}
_ => {}
}
} else if path.is_dir() {
self.load_fonts_dir(path);
}
}
}
}
#[cfg(feature = "fs")]
pub fn load_system_fonts(&mut self) {
#[cfg(target_os = "windows")]
{
self.load_fonts_dir("C:\\Windows\\Fonts\\");
}
#[cfg(target_os = "macos")]
{
self.load_fonts_dir("/Library/Fonts");
self.load_fonts_dir("/System/Library/Fonts");
self.load_fonts_dir("/Network/Library/Fonts");
if let Ok(ref home) = std::env::var("HOME") {
let path = std::path::Path::new(home).join("Library/Fonts");
self.load_fonts_dir(path);
}
}
#[cfg(all(unix, not(any(target_os = "macos", target_os = "android"))))]
{
self.load_fonts_dir("/usr/share/fonts/");
self.load_fonts_dir("/usr/local/share/fonts/");
if let Ok(ref home) = std::env::var("HOME") {
let path = std::path::Path::new(home).join(".local/share/fonts");
self.load_fonts_dir(path);
}
}
}
pub fn remove_face(&mut self, id: ID) -> bool {
match self.faces.iter().position(|item| item.id == id) {
Some(idx) => {
self.faces.remove(idx);
true
}
None => false,
}
}
#[inline]
pub fn is_empty(&self) -> bool {
self.faces.is_empty()
}
#[inline]
pub fn len(&self) -> usize {
self.faces.len()
}
pub fn set_serif_family<S: Into<String>>(&mut self, family: S) {
self.family_serif = Some(family.into());
}
pub fn set_sans_serif_family<S: Into<String>>(&mut self, family: S) {
self.family_sans_serif = Some(family.into());
}
pub fn set_cursive_family<S: Into<String>>(&mut self, family: S) {
self.family_cursive = Some(family.into());
}
pub fn set_fantasy_family<S: Into<String>>(&mut self, family: S) {
self.family_fantasy = Some(family.into());
}
pub fn set_monospace_family<S: Into<String>>(&mut self, family: S) {
self.family_monospace = Some(family.into());
}
pub fn query(&self, query: &Query) -> Option<ID> {
for family in query.families {
let name = match self.family_name(family) {
Some(name) => name,
None => continue,
};
let mut ids = Vec::new();
let mut candidates = Vec::new();
for face in self.faces.iter().filter(|face| &face.family == name) {
ids.push(face.id);
candidates.push(FaceProperties {
style: face.style,
weight: face.weight,
stretch: face.stretch,
});
}
if !candidates.is_empty() {
if let Some(index) = find_best_match(&candidates, query) {
return Some(ids[index]);
}
}
}
None
}
fn family_name<'a>(&'a self, family: &'a Family) -> Option<&'a str> {
use std::ops::Deref;
match family {
Family::Name(ref name) => Some(name),
Family::Serif => self.family_serif.as_ref().map(|t| t.deref()),
Family::SansSerif => self.family_sans_serif.as_ref().map(|t| t.deref()),
Family::Cursive => self.family_cursive.as_ref().map(|t| t.deref()),
Family::Fantasy => self.family_fantasy.as_ref().map(|t| t.deref()),
Family::Monospace => self.family_monospace.as_ref().map(|t| t.deref()),
}
}
#[inline]
pub fn faces(&self) -> &[FaceInfo] {
&self.faces
}
pub fn face(&self, id: ID) -> Option<&FaceInfo> {
self.faces.iter().find(|item| item.id == id)
}
pub fn face_source(&self, id: ID) -> Option<(Arc<Source>, u32)> {
self.face(id).map(|info| (info.source.clone(), info.index))
}
pub fn with_face_data<P, T>(&self, id: ID, p: P) -> Option<T>
where P: FnOnce(&[u8], u32) -> T
{
let (src, face_index) = self.face_source(id)?;
match &*src {
#[cfg(feature = "fs")]
Source::File(ref path) => {
let file = std::fs::File::open(path).ok()?;
let data = unsafe { &memmap2::MmapOptions::new().map(&file).ok()? };
Some(p(data, face_index))
}
Source::Binary(ref data) => {
Some(p(data, face_index))
}
}
}
}
#[derive(Clone, Debug)]
pub struct FaceInfo {
pub id: ID,
pub source: Arc<Source>,
pub index: u32,
pub family: String,
pub post_script_name: String,
pub style: Style,
pub weight: Weight,
pub stretch: Stretch,
pub monospaced: bool,
}
#[derive(Clone, Copy, PartialEq, Default, Debug)]
struct FaceProperties {
style: Style,
weight: Weight,
stretch: Stretch,
}
#[derive(Clone, Debug)]
pub enum Source {
Binary(Vec<u8>),
#[cfg(feature = "fs")]
File(PathBuf),
}
#[derive(Clone, Copy, Default, Debug)]
pub struct Query<'a> {
pub families: &'a [Family<'a>],
pub weight: Weight,
pub stretch: Stretch,
pub style: Style,
}
#[derive(Clone, Copy, Debug)]
pub enum Family<'a> {
Name(&'a str),
Serif,
SansSerif,
Cursive,
Fantasy,
Monospace,
}
#[derive(Clone, Copy, PartialOrd, PartialEq, Debug)]
pub struct Weight(pub u16);
impl Default for Weight {
#[inline]
fn default() -> Weight {
Weight::NORMAL
}
}
impl Weight {
pub const THIN: Weight = Weight(100);
pub const EXTRA_LIGHT: Weight = Weight(200);
pub const LIGHT: Weight = Weight(300);
pub const NORMAL: Weight = Weight(400);
pub const MEDIUM: Weight = Weight(500);
pub const SEMIBOLD: Weight = Weight(600);
pub const BOLD: Weight = Weight(700);
pub const EXTRA_BOLD: Weight = Weight(800);
pub const BLACK: Weight = Weight(900);
}
#[derive(Clone, Copy, PartialEq, Debug)]
pub enum Style {
Normal,
Italic,
Oblique,
}
impl Default for Style {
#[inline]
fn default() -> Style {
Style::Normal
}
}
fn parse_face_info(
id: u32,
source: Arc<Source>,
data: &[u8],
index: u32,
) -> Result<FaceInfo, LoadError> {
let face = ttf_parser::Face::from_slice(data, index).map_err(|_| LoadError::MalformedFont)?;
let family = parse_name(ttf_parser::name_id::FAMILY, &face).ok_or(LoadError::UnnamedFont)?;
let post_script_name = parse_name(ttf_parser::name_id::POST_SCRIPT_NAME, &face)
.ok_or(LoadError::UnnamedFont)?;
let style = if face.is_italic() {
Style::Italic
} else if face.is_oblique() {
Style::Oblique
} else {
Style::Normal
};
Ok(FaceInfo {
id: ID(id),
source,
index,
family,
post_script_name,
style,
weight: Weight(face.weight().to_number()),
stretch: face.width(),
monospaced: face.is_monospaced(),
})
}
fn parse_name(name_id: u16, face: &ttf_parser::Face) -> Option<String> {
let name_record = face.names().find(|name| {
name.name_id() == name_id && name.is_supported_encoding()
})?;
if name_record.is_unicode() {
name_record.to_string()
} else if name_record.is_mac_roman() {
let mut raw_data = Vec::with_capacity(name_record.name().len());
for b in name_record.name() {
raw_data.push(MAC_ROMAN[*b as usize]);
}
String::from_utf16(&raw_data).ok()
} else {
None
}
}
trait NameExt {
fn is_mac_roman(&self) -> bool;
fn is_supported_encoding(&self) -> bool;
}
impl NameExt for ttf_parser::Name<'_> {
#[inline]
fn is_mac_roman(&self) -> bool {
const MACINTOSH_ROMAN_ENCODING_ID: u16 = 0;
self.platform_id() == ttf_parser::PlatformId::Macintosh
&& self.encoding_id() == MACINTOSH_ROMAN_ENCODING_ID
}
#[inline]
fn is_supported_encoding(&self) -> bool {
self.is_unicode() || self.is_mac_roman()
}
}
#[inline(never)]
fn find_best_match(candidates: &[FaceProperties], query: &Query) -> Option<usize> {
debug_assert!(!candidates.is_empty());
let mut matching_set: Vec<usize> = (0..candidates.len()).collect();
let matches = matching_set.iter().any(|&index| candidates[index].stretch == query.stretch);
let matching_stretch = if matches {
query.stretch
} else if query.stretch <= Stretch::Normal {
let stretch = matching_set
.iter()
.filter(|&&index| candidates[index].stretch < query.stretch)
.min_by_key(|&&index| {
query.stretch.to_number() - candidates[index].stretch.to_number()
});
match stretch {
Some(&matching_index) => candidates[matching_index].stretch,
None => {
let matching_index = *matching_set
.iter()
.min_by_key(|&&index| {
candidates[index].stretch.to_number() - query.stretch.to_number()
})?;
candidates[matching_index].stretch
}
}
} else {
let stretch = matching_set
.iter()
.filter(|&&index| candidates[index].stretch > query.stretch)
.min_by_key(|&&index| {
candidates[index].stretch.to_number() - query.stretch.to_number()
});
match stretch {
Some(&matching_index) => candidates[matching_index].stretch,
None => {
let matching_index = *matching_set
.iter()
.min_by_key(|&&index| {
query.stretch.to_number() - candidates[index].stretch.to_number()
})?;
candidates[matching_index].stretch
}
}
};
matching_set.retain(|&index| candidates[index].stretch == matching_stretch);
let style_preference = match query.style {
Style::Italic => [Style::Italic, Style::Oblique, Style::Normal],
Style::Oblique => [Style::Oblique, Style::Italic, Style::Normal],
Style::Normal => [Style::Normal, Style::Oblique, Style::Italic],
};
let matching_style = *style_preference
.iter()
.filter(|&query_style| {
matching_set
.iter()
.any(|&index| candidates[index].style == *query_style)
})
.next()?;
matching_set.retain(|&index| candidates[index].style == matching_style);
let weight = query.weight.0;
let matches = weight >= 400
&& weight < 450
&& matching_set
.iter()
.any(|&index| candidates[index].weight.0 == 500);
let matching_weight = if matches {
Weight::MEDIUM
} else if weight >= 450 && weight <= 500 &&
matching_set.iter().any(|&index| candidates[index].weight.0 == 400)
{
Weight::NORMAL
} else if weight <= 500 {
let idx = matching_set
.iter()
.filter(|&&index| candidates[index].weight.0 <= weight)
.min_by_key(|&&index| weight - candidates[index].weight.0);
match idx {
Some(&matching_index) => candidates[matching_index].weight,
None => {
let matching_index = *matching_set
.iter()
.min_by_key(|&&index| candidates[index].weight.0 - weight)?;
candidates[matching_index].weight
}
}
} else {
let idx = matching_set
.iter()
.filter(|&&index| candidates[index].weight.0 >= weight)
.min_by_key(|&&index| candidates[index].weight.0 - weight);
match idx {
Some(&matching_index) => candidates[matching_index].weight,
None => {
let matching_index = *matching_set
.iter()
.min_by_key(|&&index| weight - candidates[index].weight.0)?;
candidates[matching_index].weight
}
}
};
matching_set.retain(|&index| candidates[index].weight == matching_weight);
matching_set.into_iter().next()
}
const MAC_ROMAN: &[u16; 256] = &[
0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
0x0010, 0x2318, 0x21E7, 0x2325, 0x2303, 0x0015, 0x0016, 0x0017,
0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
0x00C4, 0x00C5, 0x00C7, 0x00C9, 0x00D1, 0x00D6, 0x00DC, 0x00E1,
0x00E0, 0x00E2, 0x00E4, 0x00E3, 0x00E5, 0x00E7, 0x00E9, 0x00E8,
0x00EA, 0x00EB, 0x00ED, 0x00EC, 0x00EE, 0x00EF, 0x00F1, 0x00F3,
0x00F2, 0x00F4, 0x00F6, 0x00F5, 0x00FA, 0x00F9, 0x00FB, 0x00FC,
0x2020, 0x00B0, 0x00A2, 0x00A3, 0x00A7, 0x2022, 0x00B6, 0x00DF,
0x00AE, 0x00A9, 0x2122, 0x00B4, 0x00A8, 0x2260, 0x00C6, 0x00D8,
0x221E, 0x00B1, 0x2264, 0x2265, 0x00A5, 0x00B5, 0x2202, 0x2211,
0x220F, 0x03C0, 0x222B, 0x00AA, 0x00BA, 0x03A9, 0x00E6, 0x00F8,
0x00BF, 0x00A1, 0x00AC, 0x221A, 0x0192, 0x2248, 0x2206, 0x00AB,
0x00BB, 0x2026, 0x00A0, 0x00C0, 0x00C3, 0x00D5, 0x0152, 0x0153,
0x2013, 0x2014, 0x201C, 0x201D, 0x2018, 0x2019, 0x00F7, 0x25CA,
0x00FF, 0x0178, 0x2044, 0x20AC, 0x2039, 0x203A, 0xFB01, 0xFB02,
0x2021, 0x00B7, 0x201A, 0x201E, 0x2030, 0x00C2, 0x00CA, 0x00C1,
0x00CB, 0x00C8, 0x00CD, 0x00CE, 0x00CF, 0x00CC, 0x00D3, 0x00D4,
0xF8FF, 0x00D2, 0x00DA, 0x00DB, 0x00D9, 0x0131, 0x02C6, 0x02DC,
0x00AF, 0x02D8, 0x02D9, 0x02DA, 0x00B8, 0x02DD, 0x02DB, 0x02C7,
];