pub mod cff;
pub mod cffsubset;
pub mod cidcmap;
pub mod dsp;
pub mod features;
pub mod names;
pub mod nodes;
pub mod normalize;
pub mod ota;
pub mod otc;
pub mod otj;
pub mod otr;
pub mod ots;
pub mod ott;
pub mod oup;
pub mod procs;
pub mod registry;
pub mod stream;
pub mod tfm;
pub mod ttf;
pub mod ttsubset;
pub mod var;
pub use registry::{clear_lua_fonts, is_lua_font, lua_font, register_lua_font, LuaFont};
use std::collections::BTreeMap;
use std::sync::Arc;
use oup::Description;
#[derive(Clone, Debug)]
pub struct Face {
pub descriptions: BTreeMap<u32, Description>,
pub metadata: tfm::Metadata,
pub format: &'static str,
pub unicodes: BTreeMap<String, u32>,
pub private: u32,
pub layout: dsp::Layout,
pub expanded: oup::Expanded,
pub variants: BTreeMap<u32, BTreeMap<u32, u32>>,
}
impl Face {
pub fn open(path: impl AsRef<std::path::Path>, sub: usize) -> Result<Arc<Face>, String> {
let path = path.as_ref();
let data =
std::fs::read(path).map_err(|e| format!("cannot read {}: {e}", path.display()))?;
Face::from_bytes(&data, sub)
}
pub fn open_instance(
path: impl AsRef<std::path::Path>,
sub: usize,
instance: Option<&str>,
) -> Result<Arc<Face>, String> {
let path = path.as_ref();
let data =
std::fs::read(path).map_err(|e| format!("cannot read {}: {e}", path.display()))?;
Face::from_bytes_instance(&data, sub, instance)
}
pub fn from_bytes(data: &[u8], sub: usize) -> Result<Arc<Face>, String> {
Face::from_bytes_instance(data, sub, None)
}
pub fn from_bytes_instance(
data: &[u8],
sub: usize,
instance: Option<&str>,
) -> Result<Arc<Face>, String> {
let offsets = otr::face_offsets(data);
let offset = *offsets
.get(sub)
.ok_or_else(|| "not an OpenType font, or no such face in the collection".to_string())?;
let (mut fontdata, mut layout) = otr::read_instance(data, offset, instance);
oup::compact(&mut layout);
let (mut descriptions, indices, private) = oup::unify_glyphs(&mut fontdata);
let ix = |g: u32| indices.get(g as usize).copied();
for (gid, mut m) in std::mem::take(&mut layout.math) {
for list in [m.vvariants.as_mut(), m.hvariants.as_mut()]
.into_iter()
.flatten()
{
for g in list.iter_mut() {
*g = ix(*g).unwrap_or(*g);
}
}
for parts in [m.vparts.as_mut(), m.hparts.as_mut()].into_iter().flatten() {
for p in parts.iter_mut() {
p.glyph = ix(p.glyph).unwrap_or(p.glyph);
}
}
if let Some(d) = ix(gid).and_then(|u| descriptions.get_mut(&u)) {
d.math = Some(m);
}
}
oup::unify_resources(&mut layout, &indices, &fontdata.duplicates);
let variants: BTreeMap<u32, BTreeMap<u32, u32>> = std::mem::take(&mut fontdata.variants)
.into_iter()
.map(|(selector, m)| {
(
selector,
m.into_iter()
.filter_map(|(u, g)| ix(g).map(|s| (u, s)))
.collect(),
)
})
.collect();
oup::copy_duplicates(&mut descriptions, &fontdata.duplicates);
let mut unicodes = BTreeMap::new();
for (&u, d) in &descriptions {
if u < otr::PRIVATE && !(0xE000..=0xF8FF).contains(&u) {
if let Some(n) = &d.name {
unicodes.insert(n.clone(), u);
}
}
}
oup::add_tounicode(&mut descriptions, &mut unicodes, &oup::lookups_of(&layout));
oup::strip_redundant(&mut descriptions, true);
let unicodes = oup::unicode_table(&descriptions);
oup::expand_dimensions(&mut descriptions, 0.0);
let mut expanded = oup::expand_lookups(&mut layout);
otc::enhance(&descriptions, &mut layout, &mut expanded);
let m = fontdata.windowsmetrics.clone().unwrap_or_default();
let post = fontdata.postscript.clone().unwrap_or_default();
let head = fontdata.fontheader.clone().unwrap_or_default();
let metadata = tfm::Metadata {
units: head.units as f64,
designsize: layout.designsize,
monospaced: post.monospaced > 0 || m.panose[3] == 9,
averagewidth: Some(m.averagewidth as f64),
xheight: m.xheight.map(|x| x as f64),
capheight: m.capheight.map(|x| x as f64),
ascender: Some(m.typoascender as f64),
descender: Some(m.typodescender as f64),
italicangle: post.italicangle,
fontname: fontdata.getname("postscriptname"),
fullname: fontdata.getname("fullname"),
math: layout.mathconstants.clone(),
hasitalics: layout.hasitalics,
};
Ok(Arc::new(Face {
descriptions,
metadata,
format: fontdata.format,
unicodes,
private,
layout,
expanded,
variants,
}))
}
pub fn scale(&self, size: i64) -> tfm::Scaled {
self.scale_with(size, &tfm::Options::text())
}
pub fn scale_with(&self, size: i64, opts: &tfm::Options) -> tfm::Scaled {
tfm::scale(&self.descriptions, &self.metadata, size, opts)
}
pub fn class(&self, u: u32) -> &str {
self.descriptions
.get(&u)
.and_then(|d| d.class.as_deref())
.unwrap_or("base")
}
}