,
}
impl<'a> GlyphPainter<'a> {
fn write_gradient_stops(&mut self, stops: ttf::colr::GradientStopsIter) {
for stop in stops {
self.svg.start_element("stop");
self.svg.write_attribute("offset", &stop.stop_offset);
self.svg.write_color_attribute("stop-color", stop.color);
let opacity = f32::from(stop.color.alpha) / 255.0;
self.svg.write_attribute("stop-opacity", &opacity);
self.svg.end_element();
}
}
fn paint_solid(&mut self, color: ttf::RgbaColor) {
self.svg.start_element("path");
self.svg.write_color_attribute("fill", color);
let opacity = f32::from(color.alpha) / 255.0;
self.svg.write_attribute("fill-opacity", &opacity);
self.svg
.write_transform_attribute("transform", self.outline_transform);
self.svg.write_attribute("d", self.path_buf);
self.svg.end_element();
}
fn paint_linear_gradient(&mut self, gradient: ttf::colr::LinearGradient<'a>) {
let gradient_id = format!("lg{}", self.gradient_index);
self.gradient_index += 1;
let gradient_transform = paint_transform(self.outline_transform, self.transform);
// TODO: We ignore x2, y2. Have to apply them somehow.
// TODO: The way spreadMode works in ttf and svg is a bit different. In SVG, the spreadMode
// will always be applied based on x1/y1 and x2/y2. However, in TTF the spreadMode will
// be applied from the first/last stop. So if we have a gradient with x1=0 x2=1, and
// a stop at x=0.4 and x=0.6, then in SVG we will always see a padding, while in ttf
// we will see the actual spreadMode. We need to account for that somehow.
self.svg.start_element("linearGradient");
self.svg.write_attribute("id", &gradient_id);
self.svg.write_attribute("x1", &gradient.x0);
self.svg.write_attribute("y1", &gradient.y0);
self.svg.write_attribute("x2", &gradient.x1);
self.svg.write_attribute("y2", &gradient.y1);
self.svg.write_attribute("gradientUnits", &"userSpaceOnUse");
self.svg.write_spread_method_attribute(gradient.extend);
self.svg
.write_transform_attribute("gradientTransform", gradient_transform);
self.write_gradient_stops(gradient.stops(
self.palette_index,
#[cfg(feature = "variable-fonts")]
self.face.variation_coordinates(),
));
self.svg.end_element();
self.svg.start_element("path");
self.svg
.write_attribute_fmt("fill", format_args!("url(#{})", gradient_id));
self.svg
.write_transform_attribute("transform", self.outline_transform);
self.svg.write_attribute("d", self.path_buf);
self.svg.end_element();
}
fn paint_radial_gradient(&mut self, gradient: ttf::colr::RadialGradient<'a>) {
let gradient_id = format!("rg{}", self.gradient_index);
self.gradient_index += 1;
self.svg.start_element("radialGradient");
self.svg.write_attribute("id", &gradient_id);
self.svg.write_attribute("cx", &gradient.x1);
self.svg.write_attribute("cy", &gradient.y1);
self.svg.write_attribute("r", &gradient.r1);
self.svg.write_attribute("fr", &gradient.r0);
self.svg.write_attribute("fx", &gradient.x0);
self.svg.write_attribute("fy", &gradient.y0);
self.svg.write_attribute("gradientUnits", &"userSpaceOnUse");
self.svg.write_spread_method_attribute(gradient.extend);
self.svg
.write_transform_attribute("gradientTransform", self.transform);
self.write_gradient_stops(gradient.stops(
self.palette_index,
#[cfg(feature = "variable-fonts")]
self.face.variation_coordinates(),
));
self.svg.end_element();
self.svg.start_element("path");
self.svg
.write_attribute_fmt("fill", format_args!("url(#{})", gradient_id));
self.svg
.write_transform_attribute("transform", self.outline_transform);
self.svg.write_attribute("d", self.path_buf);
self.svg.end_element();
}
fn paint_sweep_gradient(&mut self, _: ttf::colr::SweepGradient<'a>) {
println!("Warning: sweep gradients are not supported.")
}
}
fn paint_transform(outline_transform: Transform, transform: Transform) -> Transform {
let outline_transform = tiny_skia_path::Transform::from_row(
outline_transform.a,
outline_transform.b,
outline_transform.c,
outline_transform.d,
outline_transform.e,
outline_transform.f,
);
let gradient_transform = tiny_skia_path::Transform::from_row(
transform.a,
transform.b,
transform.c,
transform.d,
transform.e,
transform.f,
);
let gradient_transform = outline_transform
.invert()
.unwrap()
.pre_concat(gradient_transform);
ttf_parser::Transform {
a: gradient_transform.sx,
b: gradient_transform.ky,
c: gradient_transform.kx,
d: gradient_transform.sy,
e: gradient_transform.tx,
f: gradient_transform.ty,
}
}
impl GlyphPainter<'_> {
fn clip_with_path(&mut self, path: &str) {
let clip_id = format!("cp{}", self.clip_path_index);
self.clip_path_index += 1;
self.svg.start_element("clipPath");
self.svg.write_attribute("id", &clip_id);
self.svg.start_element("path");
self.svg
.write_transform_attribute("transform", self.outline_transform);
self.svg.write_attribute("d", &path);
self.svg.end_element();
self.svg.end_element();
self.svg.start_element("g");
self.svg
.write_attribute_fmt("clip-path", format_args!("url(#{})", clip_id));
}
}
impl<'a> ttf::colr::Painter<'a> for GlyphPainter<'a> {
fn outline_glyph(&mut self, glyph_id: ttf::GlyphId) {
self.path_buf.clear();
let mut builder = Builder(self.path_buf);
match self.face.outline_glyph(glyph_id, &mut builder) {
Some(v) => v,
None => return,
};
builder.finish();
// We have to write outline using the current transform.
self.outline_transform = self.transform;
}
fn push_layer(&mut self, mode: ttf::colr::CompositeMode) {
self.svg.start_element("g");
use ttf::colr::CompositeMode;
// TODO: Need to figure out how to represent the other blend modes
// in SVG.
let mode = match mode {
CompositeMode::SourceOver => "normal",
CompositeMode::Screen => "screen",
CompositeMode::Overlay => "overlay",
CompositeMode::Darken => "darken",
CompositeMode::Lighten => "lighten",
CompositeMode::ColorDodge => "color-dodge",
CompositeMode::ColorBurn => "color-burn",
CompositeMode::HardLight => "hard-light",
CompositeMode::SoftLight => "soft-light",
CompositeMode::Difference => "difference",
CompositeMode::Exclusion => "exclusion",
CompositeMode::Multiply => "multiply",
CompositeMode::Hue => "hue",
CompositeMode::Saturation => "saturation",
CompositeMode::Color => "color",
CompositeMode::Luminosity => "luminosity",
_ => {
println!("Warning: unsupported blend mode: {:?}", mode);
"normal"
}
};
self.svg.write_attribute_fmt(
"style",
format_args!("mix-blend-mode: {}; isolation: isolate", mode),
);
}
fn pop_layer(&mut self) {
self.svg.end_element(); // g
}
fn push_transform(&mut self, transform: ttf::Transform) {
self.transforms_stack.push(self.transform);
self.transform = ttf::Transform::combine(self.transform, transform);
}
fn paint(&mut self, paint: Paint<'a>) {
match paint {
Paint::Solid(color) => self.paint_solid(color),
Paint::LinearGradient(lg) => self.paint_linear_gradient(lg),
Paint::RadialGradient(rg) => self.paint_radial_gradient(rg),
Paint::SweepGradient(sg) => self.paint_sweep_gradient(sg),
}
}
fn pop_transform(&mut self) {
if let Some(ts) = self.transforms_stack.pop() {
self.transform = ts
}
}
fn push_clip(&mut self) {
self.clip_with_path(&self.path_buf.clone());
}
fn pop_clip(&mut self) {
self.svg.end_element();
}
fn push_clip_box(&mut self, clipbox: ClipBox) {
let x_min = clipbox.x_min;
let x_max = clipbox.x_max;
let y_min = clipbox.y_min;
let y_max = clipbox.y_max;
let clip_path = format!(
"M {} {} L {} {} L {} {} L {} {} Z",
x_min, y_min, x_max, y_min, x_max, y_max, x_min, y_max
);
self.clip_with_path(&clip_path);
}
}
fn color_glyph(
x: f64,
y: f64,
face: &ttf::Face,
palette_index: u16,
glyph_id: ttf::GlyphId,
cell_size: f64,
scale: f64,
gradient_index: &mut usize,
clip_path_index: &mut usize,
svg: &mut xmlwriter::XmlWriter,
path_buf: &mut String,
) {
let y = y + cell_size + face.descender() as f64 * scale;
let transform = format!("matrix({} 0 0 {} {} {})", scale, -scale, x, y);
svg.start_element("g");
svg.write_attribute("transform", &transform);
let mut painter = GlyphPainter {
face,
svg,
path_buf,
gradient_index: *gradient_index,
clip_path_index: *clip_path_index,
palette_index,
transform: ttf::Transform::default(),
outline_transform: ttf::Transform::default(),
transforms_stack: vec![ttf::Transform::default()],
};
face.paint_color_glyph(
glyph_id,
palette_index,
RgbaColor::new(0, 0, 0, 255),
&mut painter,
);
*gradient_index = painter.gradient_index;
*clip_path_index = painter.clip_path_index;
svg.end_element();
}
trait XmlWriterExt {
fn write_color_attribute(&mut self, name: &str, ts: ttf::RgbaColor);
fn write_transform_attribute(&mut self, name: &str, ts: ttf::Transform);
fn write_spread_method_attribute(&mut self, method: ttf::colr::GradientExtend);
}
impl XmlWriterExt for xmlwriter::XmlWriter {
fn write_color_attribute(&mut self, name: &str, color: ttf::RgbaColor) {
self.write_attribute_fmt(
name,
format_args!("rgb({}, {}, {})", color.red, color.green, color.blue),
);
}
fn write_transform_attribute(&mut self, name: &str, ts: ttf::Transform) {
if ts.is_default() {
return;
}
self.write_attribute_fmt(
name,
format_args!(
"matrix({} {} {} {} {} {})",
ts.a, ts.b, ts.c, ts.d, ts.e, ts.f
),
);
}
fn write_spread_method_attribute(&mut self, extend: ttf::colr::GradientExtend) {
self.write_attribute(
"spreadMethod",
match extend {
ttf::colr::GradientExtend::Pad => &"pad",
ttf::colr::GradientExtend::Repeat => &"repeat",
ttf::colr::GradientExtend::Reflect => &"reflect",
},
);
}
}
ttf-parser-0.24.1/examples/wasm/.gitignore 0000644 0000000 0000000 00000000007 10461020230 0016551 0 ustar 0000000 0000000 *.wasm
ttf-parser-0.24.1/examples/wasm/README.md 0000644 0000000 0000000 00000000602 10461020230 0016041 0 ustar 0000000 0000000 # ttf-parser as a WebAssembly module
## Build
```sh
rustup target add wasm32-unknown-unknown
cargo build --target wasm32-unknown-unknown --release --manifest-path ../../c-api/Cargo.toml
cp ../../c-api/target/wasm32-unknown-unknown/release/ttfparser.wasm .
```
## Run
You can use any webserver that can serve `index.html`. Here is a Python example:
```sh
python -m http.server
```
ttf-parser-0.24.1/examples/wasm/TTC.ttc 0000644 0000000 0000000 00000005060 10461020230 0015733 0 ustar 0000000 0000000 ttcf pDSIG OS/2g# `cmap1" t cvt p fpgm t gasp x glyf R4 hheadxD 6hheaT $ $hmtx H loca ^ L ` maxp p name> bpostr% 7prep
, pDSIG OS/2g# `cmap1" t cvt p fpgm t gasp x glyf R4 hheadxD 6hheaT $ $hmtx H loca ^ L ` maxp p name> bpostr% 7prep
, 2 NONE & , \ @
. &
. &
2 3!'!222v 7 z 73#7zz 7 z & ' (n_< і7 2 2 2 2 7 7 " 4 J 4 4 < C 4
\ i ) x # # ; 4 h p 2 p R J J F\ F\ vCopyright (c) 2015 by FontTools. No rights reserved.Test TTFRegularFontTools: Test TTF: 2015Version 1.000TestTTF-RegularTest TTF is not a trademark of FontTools.FontToolshttps://github.com/behdad/fonttoolshttps://github.com/behdad/fonttools/blob/master/LICENSE.txt C o p y r i g h t ( c ) 2 0 1 5 b y F o n t T o o l s . N o r i g h t s r e s e r v e d . T e s t T T F R e g u l a r F o n t T o o l s : T e s t T T F : 2 0 1 5 V e r s i o n 1 . 0 0 0 T e s t T T F - R e g u l a r T e s t T T F i s n o t a t r a d e m a r k o f F o n t T o o l s . F o n t T o o l s h t t p s : / / g i t h u b . c o m / b e h d a d / f o n t t o o l s h t t p s : / / g i t h u b . c o m / b e h d a d / f o n t t o o l s / b l o b / m a s t e r / L I C E N S E . t x t 2 .nullCR ttf-parser-0.24.1/examples/wasm/index.html 0000644 0000000 0000000 00000004707 10461020230 0016571 0 ustar 0000000 0000000 ttf-parser in WebAssembly
(supports font files drag and drop)
TTC.ttc:
ttfp_fonts_in_collection():
ttfp_is_variable():
ttfp_get_weight():
ttf-parser-0.24.1/src/aat.rs 0000644 0000000 0000000 00000042175 10461020230 0013712 0 ustar 0000000 0000000 /*!
A collection of [Apple Advanced Typography](
https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6AATIntro.html)
related types.
*/
use core::num::NonZeroU16;
use crate::parser::{FromData, LazyArray16, NumFrom, Offset, Offset16, Offset32, Stream};
use crate::GlyphId;
/// Predefined states.
pub mod state {
#![allow(missing_docs)]
pub const START_OF_TEXT: u16 = 0;
}
/// Predefined classes.
///
/// Search for _Class Code_ in [Apple Advanced Typography Font Tables](
/// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6Tables.html).
pub mod class {
#![allow(missing_docs)]
pub const END_OF_TEXT: u8 = 0;
pub const OUT_OF_BOUNDS: u8 = 1;
pub const DELETED_GLYPH: u8 = 2;
}
/// A State Table entry.
///
/// Used by legacy and extended tables.
#[derive(Clone, Copy, Debug)]
pub struct GenericStateEntry {
/// A new state.
pub new_state: u16,
/// Entry flags.
pub flags: u16,
/// Additional data.
///
/// Use `()` if no data expected.
pub extra: T,
}
impl FromData for GenericStateEntry {
const SIZE: usize = 4 + T::SIZE;
#[inline]
fn parse(data: &[u8]) -> Option {
let mut s = Stream::new(data);
Some(GenericStateEntry {
new_state: s.read::()?,
flags: s.read::()?,
extra: s.read::()?,
})
}
}
impl GenericStateEntry {
/// Checks that entry has an offset.
#[inline]
pub fn has_offset(&self) -> bool {
self.flags & 0x3FFF != 0
}
/// Returns a value offset.
///
/// Used by kern::format1 subtable.
#[inline]
pub fn value_offset(&self) -> ValueOffset {
ValueOffset(self.flags & 0x3FFF)
}
/// If set, reset the kerning data (clear the stack).
#[inline]
pub fn has_reset(&self) -> bool {
self.flags & 0x2000 != 0
}
/// If set, advance to the next glyph before going to the new state.
#[inline]
pub fn has_advance(&self) -> bool {
self.flags & 0x4000 == 0
}
/// If set, push this glyph on the kerning stack.
#[inline]
pub fn has_push(&self) -> bool {
self.flags & 0x8000 != 0
}
/// If set, remember this glyph as the marked glyph.
///
/// Used by kerx::format4 subtable.
///
/// Yes, the same as [`has_push`](Self::has_push).
#[inline]
pub fn has_mark(&self) -> bool {
self.flags & 0x8000 != 0
}
}
/// A legacy state entry used by [StateTable].
pub type StateEntry = GenericStateEntry<()>;
/// A type-safe wrapper for a kerning value offset.
#[derive(Clone, Copy, Debug)]
pub struct ValueOffset(u16);
impl ValueOffset {
/// Returns the next offset.
///
/// After reaching u16::MAX will start from 0.
#[inline]
pub fn next(self) -> Self {
ValueOffset(self.0.wrapping_add(u16::SIZE as u16))
}
}
/// A [State Table](
/// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6Tables.html).
///
/// Also called `STHeader`.
///
/// Currently used by `kern` table.
#[derive(Clone)]
pub struct StateTable<'a> {
number_of_classes: u16,
first_glyph: GlyphId,
class_table: &'a [u8],
state_array_offset: u16,
state_array: &'a [u8],
entry_table: &'a [u8],
actions: &'a [u8],
}
impl<'a> StateTable<'a> {
pub(crate) fn parse(data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
let number_of_classes: u16 = s.read()?;
// Note that in format1 subtable, offsets are not from the subtable start,
// but from subtable start + `header_size`.
// So there is not need to subtract the `header_size`.
let class_table_offset = s.read::()?.to_usize();
let state_array_offset = s.read::()?.to_usize();
let entry_table_offset = s.read::()?.to_usize();
// Ignore `values_offset` since we don't use it.
// Parse class subtable.
let mut s = Stream::new_at(data, class_table_offset)?;
let first_glyph: GlyphId = s.read()?;
let number_of_glyphs: u16 = s.read()?;
// The class table contains u8, so it's easier to use just a slice
// instead of a LazyArray.
let class_table = s.read_bytes(usize::from(number_of_glyphs))?;
Some(StateTable {
number_of_classes,
first_glyph,
class_table,
state_array_offset: state_array_offset as u16,
// We don't know the actual data size and it's kinda expensive to calculate.
// So we are simply storing all the data past the offset.
// Despite the fact that they may overlap.
state_array: data.get(state_array_offset..)?,
entry_table: data.get(entry_table_offset..)?,
// `ValueOffset` defines an offset from the start of the subtable data.
// We do not check that the provided offset is actually after `values_offset`.
actions: data,
})
}
/// Returns a glyph class.
#[inline]
pub fn class(&self, glyph_id: GlyphId) -> Option {
if glyph_id.0 == 0xFFFF {
return Some(class::DELETED_GLYPH);
}
let idx = glyph_id.0.checked_sub(self.first_glyph.0)?;
self.class_table.get(usize::from(idx)).copied()
}
/// Returns a class entry.
#[inline]
pub fn entry(&self, state: u16, mut class: u8) -> Option {
if u16::from(class) >= self.number_of_classes {
class = class::OUT_OF_BOUNDS;
}
let entry_idx = self
.state_array
.get(usize::from(state) * usize::from(self.number_of_classes) + usize::from(class))?;
Stream::read_at(self.entry_table, usize::from(*entry_idx) * StateEntry::SIZE)
}
/// Returns kerning at offset.
#[inline]
pub fn kerning(&self, offset: ValueOffset) -> Option {
Stream::read_at(self.actions, usize::from(offset.0))
}
/// Produces a new state.
#[inline]
pub fn new_state(&self, state: u16) -> u16 {
let n = (i32::from(state) - i32::from(self.state_array_offset))
/ i32::from(self.number_of_classes);
use core::convert::TryFrom;
u16::try_from(n).unwrap_or(0)
}
}
impl core::fmt::Debug for StateTable<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
write!(f, "StateTable {{ ... }}")
}
}
/// An [Extended State Table](
/// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6Tables.html).
///
/// Also called `STXHeader`.
///
/// Currently used by `kerx` and `morx` tables.
#[derive(Clone)]
pub struct ExtendedStateTable<'a, T> {
number_of_classes: u32,
lookup: Lookup<'a>,
state_array: &'a [u8],
entry_table: &'a [u8],
entry_type: core::marker::PhantomData,
}
impl<'a, T: FromData> ExtendedStateTable<'a, T> {
// TODO: make private
/// Parses an Extended State Table from a stream.
///
/// `number_of_glyphs` is from the `maxp` table.
pub fn parse(number_of_glyphs: NonZeroU16, s: &mut Stream<'a>) -> Option {
let data = s.tail()?;
let number_of_classes = s.read::()?;
// Note that offsets are not from the subtable start,
// but from subtable start + `header_size`.
// So there is not need to subtract the `header_size`.
let lookup_table_offset = s.read::()?.to_usize();
let state_array_offset = s.read::()?.to_usize();
let entry_table_offset = s.read::()?.to_usize();
Some(ExtendedStateTable {
number_of_classes,
lookup: Lookup::parse(number_of_glyphs, data.get(lookup_table_offset..)?)?,
// We don't know the actual data size and it's kinda expensive to calculate.
// So we are simply storing all the data past the offset.
// Despite the fact that they may overlap.
state_array: data.get(state_array_offset..)?,
entry_table: data.get(entry_table_offset..)?,
entry_type: core::marker::PhantomData,
})
}
/// Returns a glyph class.
#[inline]
pub fn class(&self, glyph_id: GlyphId) -> Option {
if glyph_id.0 == 0xFFFF {
return Some(u16::from(class::DELETED_GLYPH));
}
self.lookup.value(glyph_id)
}
/// Returns a class entry.
#[inline]
pub fn entry(&self, state: u16, mut class: u16) -> Option> {
if u32::from(class) >= self.number_of_classes {
class = u16::from(class::OUT_OF_BOUNDS);
}
let state_idx =
usize::from(state) * usize::num_from(self.number_of_classes) + usize::from(class);
let entry_idx: u16 = Stream::read_at(self.state_array, state_idx * u16::SIZE)?;
Stream::read_at(
self.entry_table,
usize::from(entry_idx) * GenericStateEntry::::SIZE,
)
}
}
impl core::fmt::Debug for ExtendedStateTable<'_, T> {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
write!(f, "ExtendedStateTable {{ ... }}")
}
}
/// A [lookup table](
/// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6Tables.html).
///
/// u32 values in Format10 tables will be truncated to u16.
/// u64 values in Format10 tables are not supported.
#[derive(Clone)]
pub struct Lookup<'a> {
data: LookupInner<'a>,
}
impl<'a> Lookup<'a> {
/// Parses a lookup table from raw data.
///
/// `number_of_glyphs` is from the `maxp` table.
#[inline]
pub fn parse(number_of_glyphs: NonZeroU16, data: &'a [u8]) -> Option {
LookupInner::parse(number_of_glyphs, data).map(|data| Self { data })
}
/// Returns a value associated with the specified glyph.
#[inline]
pub fn value(&self, glyph_id: GlyphId) -> Option {
self.data.value(glyph_id)
}
}
impl core::fmt::Debug for Lookup<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
write!(f, "Lookup {{ ... }}")
}
}
#[derive(Clone)]
enum LookupInner<'a> {
Format1(LazyArray16<'a, u16>),
Format2(BinarySearchTable<'a, LookupSegment>),
Format4(BinarySearchTable<'a, LookupSegment>, &'a [u8]),
Format6(BinarySearchTable<'a, LookupSingle>),
Format8 {
first_glyph: u16,
values: LazyArray16<'a, u16>,
},
Format10 {
value_size: u16,
first_glyph: u16,
glyph_count: u16,
data: &'a [u8],
},
}
impl<'a> LookupInner<'a> {
fn parse(number_of_glyphs: NonZeroU16, data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
let format = s.read::()?;
match format {
0 => {
let values = s.read_array16::(number_of_glyphs.get())?;
Some(Self::Format1(values))
}
2 => {
let bsearch = BinarySearchTable::::parse(s.tail()?)?;
Some(Self::Format2(bsearch))
}
4 => {
let bsearch = BinarySearchTable::::parse(s.tail()?)?;
Some(Self::Format4(bsearch, data))
}
6 => {
let bsearch = BinarySearchTable::::parse(s.tail()?)?;
Some(Self::Format6(bsearch))
}
8 => {
let first_glyph = s.read::()?;
let glyph_count = s.read::()?;
let values = s.read_array16::(glyph_count)?;
Some(Self::Format8 {
first_glyph,
values,
})
}
10 => {
let value_size = s.read::()?;
let first_glyph = s.read::()?;
let glyph_count = s.read::()?;
Some(Self::Format10 {
value_size,
first_glyph,
glyph_count,
data: s.tail()?,
})
}
_ => None,
}
}
fn value(&self, glyph_id: GlyphId) -> Option {
match self {
Self::Format1(values) => values.get(glyph_id.0),
Self::Format2(ref bsearch) => bsearch.get(glyph_id).map(|v| v.value),
Self::Format4(ref bsearch, data) => {
// In format 4, LookupSegment contains an offset to a list of u16 values.
// One value for each glyph in the LookupSegment range.
let segment = bsearch.get(glyph_id)?;
let index = glyph_id.0.checked_sub(segment.first_glyph)?;
let offset = usize::from(segment.value) + u16::SIZE * usize::from(index);
Stream::read_at::(data, offset)
}
Self::Format6(ref bsearch) => bsearch.get(glyph_id).map(|v| v.value),
Self::Format8 {
first_glyph,
values,
} => {
let idx = glyph_id.0.checked_sub(*first_glyph)?;
values.get(idx)
}
Self::Format10 {
value_size,
first_glyph,
glyph_count,
data,
} => {
let idx = glyph_id.0.checked_sub(*first_glyph)?;
let mut s = Stream::new(data);
match value_size {
1 => s.read_array16::(*glyph_count)?.get(idx).map(u16::from),
2 => s.read_array16::(*glyph_count)?.get(idx),
// TODO: we should return u32 here, but this is not supported yet
4 => s
.read_array16::(*glyph_count)?
.get(idx)
.map(|n| n as u16),
_ => None, // 8 is also supported
}
}
}
}
}
/// A binary searching table as defined at
/// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6Tables.html
#[derive(Clone)]
struct BinarySearchTable<'a, T: BinarySearchValue> {
values: LazyArray16<'a, T>,
len: NonZeroU16, // values length excluding termination segment
}
impl<'a, T: BinarySearchValue + core::fmt::Debug> BinarySearchTable<'a, T> {
#[inline(never)]
fn parse(data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
let segment_size = s.read::()?;
let number_of_segments = s.read::()?;
s.advance(6); // search_range + entry_selector + range_shift
if usize::from(segment_size) != T::SIZE {
return None;
}
if number_of_segments == 0 {
return None;
}
let values = s.read_array16::(number_of_segments)?;
// 'The number of termination values that need to be included is table-specific.
// The value that indicates binary search termination is 0xFFFF.'
let mut len = number_of_segments;
if values.last()?.is_termination() {
len = len.checked_sub(1)?;
}
Some(BinarySearchTable {
len: NonZeroU16::new(len)?,
values,
})
}
fn get(&self, key: GlyphId) -> Option {
let mut min = 0;
let mut max = (self.len.get() as isize) - 1;
while min <= max {
let mid = (min + max) / 2;
let v = self.values.get(mid as u16)?;
match v.contains(key) {
core::cmp::Ordering::Less => max = mid - 1,
core::cmp::Ordering::Greater => min = mid + 1,
core::cmp::Ordering::Equal => return Some(v),
}
}
None
}
}
trait BinarySearchValue: FromData {
fn is_termination(&self) -> bool;
fn contains(&self, glyph_id: GlyphId) -> core::cmp::Ordering;
}
#[derive(Clone, Copy, Debug)]
struct LookupSegment {
last_glyph: u16,
first_glyph: u16,
value: u16,
}
impl FromData for LookupSegment {
const SIZE: usize = 6;
#[inline]
fn parse(data: &[u8]) -> Option {
let mut s = Stream::new(data);
Some(LookupSegment {
last_glyph: s.read::()?,
first_glyph: s.read::()?,
value: s.read::()?,
})
}
}
impl BinarySearchValue for LookupSegment {
#[inline]
fn is_termination(&self) -> bool {
self.last_glyph == 0xFFFF && self.first_glyph == 0xFFFF
}
#[inline]
fn contains(&self, id: GlyphId) -> core::cmp::Ordering {
if id.0 < self.first_glyph {
core::cmp::Ordering::Less
} else if id.0 <= self.last_glyph {
core::cmp::Ordering::Equal
} else {
core::cmp::Ordering::Greater
}
}
}
#[derive(Clone, Copy, Debug)]
struct LookupSingle {
glyph: u16,
value: u16,
}
impl FromData for LookupSingle {
const SIZE: usize = 4;
#[inline]
fn parse(data: &[u8]) -> Option {
let mut s = Stream::new(data);
Some(LookupSingle {
glyph: s.read::()?,
value: s.read::()?,
})
}
}
impl BinarySearchValue for LookupSingle {
#[inline]
fn is_termination(&self) -> bool {
self.glyph == 0xFFFF
}
#[inline]
fn contains(&self, id: GlyphId) -> core::cmp::Ordering {
id.0.cmp(&self.glyph)
}
}
ttf-parser-0.24.1/src/delta_set.rs 0000644 0000000 0000000 00000002653 10461020230 0015106 0 ustar 0000000 0000000 use core::convert::TryFrom;
use crate::parser::Stream;
#[derive(Clone, Copy, Debug)]
pub(crate) struct DeltaSetIndexMap<'a> {
data: &'a [u8],
}
impl<'a> DeltaSetIndexMap<'a> {
#[inline]
pub(crate) fn new(data: &'a [u8]) -> Self {
DeltaSetIndexMap { data }
}
#[inline]
pub(crate) fn map(&self, mut index: u32) -> Option<(u16, u16)> {
let mut s = Stream::new(self.data);
let format = s.read::()?;
let entry_format = s.read::()?;
let map_count = if format == 0 {
s.read::()? as u32
} else {
s.read::()?
};
if map_count == 0 {
return None;
}
// 'If a given glyph ID is greater than mapCount-1, then the last entry is used.'
if index >= map_count {
index = map_count - 1;
}
let entry_size = ((entry_format >> 4) & 3) + 1;
let inner_index_bit_count = u32::from((entry_format & 0xF) + 1);
s.advance(usize::from(entry_size) * usize::try_from(index).ok()?);
let mut n = 0u32;
for b in s.read_bytes(usize::from(entry_size))? {
n = (n << 8) + u32::from(*b);
}
let outer_index = n >> inner_index_bit_count;
let inner_index = n & ((1 << inner_index_bit_count) - 1);
Some((
u16::try_from(outer_index).ok()?,
u16::try_from(inner_index).ok()?,
))
}
}
ttf-parser-0.24.1/src/ggg/chained_context.rs 0000644 0000000 0000000 00000012575 10461020230 0017051 0 ustar 0000000 0000000 use super::{ClassDefinition, Coverage, SequenceLookupRecord};
use crate::parser::{FromSlice, LazyArray16, LazyOffsetArray16, Offset, Offset16, Stream};
/// A [Chained Contextual Lookup Subtable](
/// https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#chseqctxt1).
#[allow(missing_docs)]
#[derive(Clone, Copy, Debug)]
pub enum ChainedContextLookup<'a> {
/// Simple glyph contexts.
Format1 {
coverage: Coverage<'a>,
sets: ChainedSequenceRuleSets<'a>,
},
/// Class-based glyph contexts.
Format2 {
coverage: Coverage<'a>,
backtrack_classes: ClassDefinition<'a>,
input_classes: ClassDefinition<'a>,
lookahead_classes: ClassDefinition<'a>,
sets: ChainedSequenceRuleSets<'a>,
},
/// Coverage-based glyph contexts.
Format3 {
coverage: Coverage<'a>,
backtrack_coverages: LazyOffsetArray16<'a, Coverage<'a>>,
input_coverages: LazyOffsetArray16<'a, Coverage<'a>>,
lookahead_coverages: LazyOffsetArray16<'a, Coverage<'a>>,
lookups: LazyArray16<'a, SequenceLookupRecord>,
},
}
impl<'a> ChainedContextLookup<'a> {
pub(crate) fn parse(data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
match s.read::()? {
1 => {
let coverage = Coverage::parse(s.read_at_offset16(data)?)?;
let count = s.read::()?;
let offsets = s.read_array16(count)?;
Some(Self::Format1 {
coverage,
sets: ChainedSequenceRuleSets::new(data, offsets),
})
}
2 => {
let coverage = Coverage::parse(s.read_at_offset16(data)?)?;
let mut parse_func = || match s.read::>()? {
Some(offset) => Some(ClassDefinition::parse(data.get(offset.to_usize()..)?)?),
None => Some(ClassDefinition::Empty),
};
let backtrack_classes = parse_func()?;
let input_classes = parse_func()?;
let lookahead_classes = parse_func()?;
let count = s.read::()?;
let offsets = s.read_array16(count)?;
Some(Self::Format2 {
coverage,
backtrack_classes,
input_classes,
lookahead_classes,
sets: LazyOffsetArray16::new(data, offsets),
})
}
3 => {
let backtrack_count = s.read::()?;
let backtrack_coverages = s.read_array16(backtrack_count)?;
let input_count = s.read::()?;
let coverage = Coverage::parse(s.read_at_offset16(data)?)?;
let input_coverages = s.read_array16(input_count.checked_sub(1)?)?;
let lookahead_count = s.read::()?;
let lookahead_coverages = s.read_array16(lookahead_count)?;
let lookup_count = s.read::()?;
let lookups = s.read_array16(lookup_count)?;
Some(Self::Format3 {
coverage,
backtrack_coverages: LazyOffsetArray16::new(data, backtrack_coverages),
input_coverages: LazyOffsetArray16::new(data, input_coverages),
lookahead_coverages: LazyOffsetArray16::new(data, lookahead_coverages),
lookups,
})
}
_ => None,
}
}
/// Returns the subtable coverage.
#[inline]
pub fn coverage(&self) -> Coverage<'a> {
match self {
Self::Format1 { coverage, .. } => *coverage,
Self::Format2 { coverage, .. } => *coverage,
Self::Format3 { coverage, .. } => *coverage,
}
}
}
/// A list of [`ChainedSequenceRule`] sets.
pub type ChainedSequenceRuleSets<'a> = LazyOffsetArray16<'a, ChainedSequenceRuleSet<'a>>;
/// A set of [`ChainedSequenceRule`].
pub type ChainedSequenceRuleSet<'a> = LazyOffsetArray16<'a, ChainedSequenceRule<'a>>;
impl<'a> FromSlice<'a> for ChainedSequenceRuleSet<'a> {
fn parse(data: &'a [u8]) -> Option {
Self::parse(data)
}
}
/// A [Chained Sequence Rule](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#chained-sequence-context-format-1-simple-glyph-contexts).
#[allow(missing_docs)]
#[derive(Clone, Copy, Debug)]
pub struct ChainedSequenceRule<'a> {
/// Contains either glyph IDs or glyph Classes.
pub backtrack: LazyArray16<'a, u16>,
pub input: LazyArray16<'a, u16>,
/// Contains either glyph IDs or glyph Classes.
pub lookahead: LazyArray16<'a, u16>,
pub lookups: LazyArray16<'a, SequenceLookupRecord>,
}
impl<'a> FromSlice<'a> for ChainedSequenceRule<'a> {
fn parse(data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
let backtrack_count = s.read::()?;
let backtrack = s.read_array16(backtrack_count)?;
let input_count = s.read::()?;
let input = s.read_array16(input_count.checked_sub(1)?)?;
let lookahead_count = s.read::()?;
let lookahead = s.read_array16(lookahead_count)?;
let lookup_count = s.read::()?;
let lookups = s.read_array16(lookup_count)?;
Some(Self {
backtrack,
input,
lookahead,
lookups,
})
}
}
ttf-parser-0.24.1/src/ggg/context.rs 0000644 0000000 0000000 00000010046 10461020230 0015365 0 ustar 0000000 0000000 use super::{ClassDefinition, Coverage, LookupIndex};
use crate::parser::{FromData, FromSlice, LazyArray16, LazyOffsetArray16, Stream};
/// A [Contextual Lookup Subtable](
/// https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#seqctxt1).
#[allow(missing_docs)]
#[derive(Clone, Copy, Debug)]
pub enum ContextLookup<'a> {
/// Simple glyph contexts.
Format1 {
coverage: Coverage<'a>,
sets: SequenceRuleSets<'a>,
},
/// Class-based glyph contexts.
Format2 {
coverage: Coverage<'a>,
classes: ClassDefinition<'a>,
sets: SequenceRuleSets<'a>,
},
/// Coverage-based glyph contexts.
Format3 {
coverage: Coverage<'a>,
coverages: LazyOffsetArray16<'a, Coverage<'a>>,
lookups: LazyArray16<'a, SequenceLookupRecord>,
},
}
impl<'a> ContextLookup<'a> {
pub(crate) fn parse(data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
match s.read::()? {
1 => {
let coverage = Coverage::parse(s.read_at_offset16(data)?)?;
let count = s.read::()?;
let offsets = s.read_array16(count)?;
Some(Self::Format1 {
coverage,
sets: SequenceRuleSets::new(data, offsets),
})
}
2 => {
let coverage = Coverage::parse(s.read_at_offset16(data)?)?;
let classes = ClassDefinition::parse(s.read_at_offset16(data)?)?;
let count = s.read::()?;
let offsets = s.read_array16(count)?;
Some(Self::Format2 {
coverage,
classes,
sets: SequenceRuleSets::new(data, offsets),
})
}
3 => {
let input_count = s.read::()?;
let lookup_count = s.read::()?;
let coverage = Coverage::parse(s.read_at_offset16(data)?)?;
let coverages = s.read_array16(input_count.checked_sub(1)?)?;
let lookups = s.read_array16(lookup_count)?;
Some(Self::Format3 {
coverage,
coverages: LazyOffsetArray16::new(data, coverages),
lookups,
})
}
_ => None,
}
}
/// Returns the subtable coverage.
#[inline]
pub fn coverage(&self) -> Coverage<'a> {
match self {
Self::Format1 { coverage, .. } => *coverage,
Self::Format2 { coverage, .. } => *coverage,
Self::Format3 { coverage, .. } => *coverage,
}
}
}
/// A list of [`SequenceRuleSet`]s.
pub type SequenceRuleSets<'a> = LazyOffsetArray16<'a, SequenceRuleSet<'a>>;
impl<'a> FromSlice<'a> for SequenceRuleSet<'a> {
fn parse(data: &'a [u8]) -> Option {
Self::parse(data)
}
}
impl<'a> FromSlice<'a> for SequenceRule<'a> {
fn parse(data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
let input_count = s.read::()?;
let lookup_count = s.read::()?;
let input = s.read_array16(input_count.checked_sub(1)?)?;
let lookups = s.read_array16(lookup_count)?;
Some(Self { input, lookups })
}
}
/// A set of [`SequenceRule`]s.
pub type SequenceRuleSet<'a> = LazyOffsetArray16<'a, SequenceRule<'a>>;
/// A sequence rule.
#[allow(missing_docs)]
#[derive(Clone, Copy, Debug)]
pub struct SequenceRule<'a> {
pub input: LazyArray16<'a, u16>,
pub lookups: LazyArray16<'a, SequenceLookupRecord>,
}
/// A sequence rule record.
#[allow(missing_docs)]
#[derive(Clone, Copy, Debug)]
pub struct SequenceLookupRecord {
pub sequence_index: u16,
pub lookup_list_index: LookupIndex,
}
impl FromData for SequenceLookupRecord {
const SIZE: usize = 4;
#[inline]
fn parse(data: &[u8]) -> Option {
let mut s = Stream::new(data);
Some(Self {
sequence_index: s.read::()?,
lookup_list_index: s.read::()?,
})
}
}
ttf-parser-0.24.1/src/ggg/feature_variations.rs 0000644 0000000 0000000 00000012447 10461020230 0017602 0 ustar 0000000 0000000 use super::{Feature, FeatureIndex, RecordListItem, VariationIndex};
use crate::parser::{FromData, LazyArray16, LazyArray32};
use crate::parser::{Offset, Offset32, Stream};
use crate::{NormalizedCoordinate, Tag};
/// A [Feature Variations Table](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#featurevariations-table).
#[derive(Clone, Copy, Debug)]
pub struct FeatureVariations<'a> {
data: &'a [u8],
records: LazyArray32<'a, FeatureVariationRecord>,
}
impl<'a> FeatureVariations<'a> {
pub(crate) fn parse(data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
let major_version = s.read::()?;
s.skip::(); // minor version
if major_version != 1 {
return None;
}
let count = s.read::()?;
let records = s.read_array32(count)?;
Some(Self { data, records })
}
/// Returns a [`VariationIndex`] for variation coordinates.
pub fn find_index(&self, coords: &[NormalizedCoordinate]) -> Option {
for i in 0..self.records.len() {
let record = self.records.get(i)?;
let offset = record.conditions.to_usize();
let set = ConditionSet::parse(self.data.get(offset..)?)?;
if set.evaluate(coords) {
return Some(i);
}
}
None
}
/// Returns a [`Feature`] at specified indices.
pub fn find_substitute(
&self,
feature_index: FeatureIndex,
variation_index: VariationIndex,
) -> Option> {
let offset = self.records.get(variation_index)?.substitutions.to_usize();
let subst = FeatureTableSubstitution::parse(self.data.get(offset..)?)?;
subst.find_substitute(feature_index)
}
}
#[derive(Clone, Copy, Debug)]
struct FeatureVariationRecord {
conditions: Offset32,
substitutions: Offset32,
}
impl FromData for FeatureVariationRecord {
const SIZE: usize = 8;
#[inline]
fn parse(data: &[u8]) -> Option {
let mut s = Stream::new(data);
Some(Self {
conditions: s.read::()?,
substitutions: s.read::()?,
})
}
}
#[derive(Clone, Copy, Debug)]
struct ConditionSet<'a> {
data: &'a [u8],
conditions: LazyArray16<'a, Offset32>,
}
impl<'a> ConditionSet<'a> {
fn parse(data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
let count = s.read::()?;
let conditions = s.read_array16(count)?;
Some(Self { data, conditions })
}
fn evaluate(&self, coords: &[NormalizedCoordinate]) -> bool {
self.conditions.into_iter().all(|offset| {
self.data
.get(offset.to_usize()..)
.and_then(Condition::parse)
.map_or(false, |c| c.evaluate(coords))
})
}
}
#[derive(Clone, Copy, Debug)]
enum Condition {
Format1 {
axis_index: u16,
filter_range_min: i16,
filter_range_max: i16,
},
}
impl Condition {
fn parse(data: &[u8]) -> Option {
let mut s = Stream::new(data);
let format = s.read::()?;
match format {
1 => {
let axis_index = s.read::()?;
let filter_range_min = s.read::()?;
let filter_range_max = s.read::()?;
Some(Self::Format1 {
axis_index,
filter_range_min,
filter_range_max,
})
}
_ => None,
}
}
fn evaluate(&self, coords: &[NormalizedCoordinate]) -> bool {
let Self::Format1 {
axis_index,
filter_range_min,
filter_range_max,
} = *self;
let coord = coords
.get(usize::from(axis_index))
.map(|c| c.get())
.unwrap_or(0);
filter_range_min <= coord && coord <= filter_range_max
}
}
#[derive(Clone, Copy, Debug)]
struct FeatureTableSubstitution<'a> {
data: &'a [u8],
records: LazyArray16<'a, FeatureTableSubstitutionRecord>,
}
impl<'a> FeatureTableSubstitution<'a> {
fn parse(data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
let major_version = s.read::()?;
s.skip::(); // minor version
if major_version != 1 {
return None;
}
let count = s.read::()?;
let records = s.read_array16(count)?;
Some(Self { data, records })
}
fn find_substitute(&self, feature_index: FeatureIndex) -> Option> {
for record in self.records {
if record.feature_index == feature_index {
let offset = record.feature.to_usize();
// TODO: set tag
return Feature::parse(Tag::from_bytes(b"DFLT"), self.data.get(offset..)?);
}
}
None
}
}
#[derive(Clone, Copy, Debug)]
struct FeatureTableSubstitutionRecord {
feature_index: FeatureIndex,
feature: Offset32,
}
impl FromData for FeatureTableSubstitutionRecord {
const SIZE: usize = 6;
#[inline]
fn parse(data: &[u8]) -> Option {
let mut s = Stream::new(data);
Some(Self {
feature_index: s.read::()?,
feature: s.read::()?,
})
}
}
ttf-parser-0.24.1/src/ggg/layout_table.rs 0000644 0000000 0000000 00000020606 10461020230 0016370 0 ustar 0000000 0000000 // Suppresses `minor_version` variable warning.
#![allow(unused_variables)]
#[cfg(feature = "variable-fonts")]
use super::FeatureVariations;
use super::LookupList;
#[cfg(feature = "variable-fonts")]
use crate::parser::Offset32;
use crate::parser::{FromData, LazyArray16, Offset, Offset16, Stream};
use crate::Tag;
/// A [Layout Table](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#table-organization).
#[derive(Clone, Copy, Debug)]
pub struct LayoutTable<'a> {
/// A list of all supported scripts.
pub scripts: ScriptList<'a>,
/// A list of all supported features.
pub features: FeatureList<'a>,
/// A list of all lookups.
pub lookups: LookupList<'a>,
/// Used to substitute an alternate set of lookup tables
/// to use for any given feature under specified conditions.
#[cfg(feature = "variable-fonts")]
pub variations: Option>,
}
impl<'a> LayoutTable<'a> {
pub(crate) fn parse(data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
let major_version = s.read::()?;
let minor_version = s.read::()?;
if major_version != 1 {
return None;
}
let scripts = ScriptList::parse(s.read_at_offset16(data)?)?;
let features = FeatureList::parse(s.read_at_offset16(data)?)?;
let lookups = LookupList::parse(s.read_at_offset16(data)?)?;
#[cfg(feature = "variable-fonts")]
{
let mut variations_offset = None;
if minor_version >= 1 {
variations_offset = s.read::>()?;
}
let variations = match variations_offset {
Some(offset) => data
.get(offset.to_usize()..)
.and_then(FeatureVariations::parse),
None => None,
};
Some(Self {
scripts,
features,
lookups,
variations,
})
}
#[cfg(not(feature = "variable-fonts"))]
{
Some(Self {
scripts,
features,
lookups,
})
}
}
}
/// An index in [`ScriptList`].
pub type ScriptIndex = u16;
/// An index in [`LanguageSystemList`].
pub type LanguageIndex = u16;
/// An index in [`FeatureList`].
pub type FeatureIndex = u16;
/// An index in [`LookupList`].
pub type LookupIndex = u16;
/// An index in [`FeatureVariations`].
pub type VariationIndex = u32;
/// A trait to parse item in [`RecordList`].
///
/// Internal use only.
pub trait RecordListItem<'a>: Sized {
/// Parses raw data.
fn parse(tag: Tag, data: &'a [u8]) -> Option;
}
/// A data storage used by [`ScriptList`], [`LanguageSystemList`] and [`FeatureList`] data types.
#[derive(Clone, Copy, Debug)]
pub struct RecordList<'a, T: RecordListItem<'a>> {
data: &'a [u8],
records: LazyArray16<'a, TagRecord>,
data_type: core::marker::PhantomData,
}
impl<'a, T: RecordListItem<'a>> RecordList<'a, T> {
fn parse(data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
let count = s.read::()?;
let records = s.read_array16(count)?;
Some(Self {
data,
records,
data_type: core::marker::PhantomData,
})
}
/// Returns a number of items in the RecordList.
pub fn len(&self) -> u16 {
self.records.len()
}
/// Checks that RecordList is empty.
pub fn is_empty(&self) -> bool {
self.records.is_empty()
}
/// Returns RecordList value by index.
pub fn get(&self, index: u16) -> Option {
let record = self.records.get(index)?;
self.data
.get(record.offset.to_usize()..)
.and_then(|data| T::parse(record.tag, data))
}
/// Returns RecordList value by [`Tag`].
pub fn find(&self, tag: Tag) -> Option {
let record = self
.records
.binary_search_by(|record| record.tag.cmp(&tag))
.map(|p| p.1)?;
self.data
.get(record.offset.to_usize()..)
.and_then(|data| T::parse(record.tag, data))
}
/// Returns RecordList value index by [`Tag`].
pub fn index(&self, tag: Tag) -> Option {
self.records
.binary_search_by(|record| record.tag.cmp(&tag))
.map(|p| p.0)
}
}
impl<'a, T: RecordListItem<'a>> IntoIterator for RecordList<'a, T> {
type Item = T;
type IntoIter = RecordListIter<'a, T>;
#[inline]
fn into_iter(self) -> Self::IntoIter {
RecordListIter {
list: self,
index: 0,
}
}
}
/// An iterator over [`RecordList`] values.
#[allow(missing_debug_implementations)]
pub struct RecordListIter<'a, T: RecordListItem<'a>> {
list: RecordList<'a, T>,
index: u16,
}
impl<'a, T: RecordListItem<'a>> Iterator for RecordListIter<'a, T> {
type Item = T;
fn next(&mut self) -> Option {
if self.index < self.list.len() {
self.index += 1;
self.list.get(self.index - 1)
} else {
None
}
}
}
/// A list of [`Script`] records.
pub type ScriptList<'a> = RecordList<'a, Script<'a>>;
/// A list of [`LanguageSystem`] records.
pub type LanguageSystemList<'a> = RecordList<'a, LanguageSystem<'a>>;
/// A list of [`Feature`] records.
pub type FeatureList<'a> = RecordList<'a, Feature<'a>>;
#[derive(Clone, Copy, Debug)]
struct TagRecord {
tag: Tag,
offset: Offset16,
}
impl FromData for TagRecord {
const SIZE: usize = 6;
#[inline]
fn parse(data: &[u8]) -> Option {
let mut s = Stream::new(data);
Some(Self {
tag: s.read::()?,
offset: s.read::()?,
})
}
}
/// A [Script Table](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#script-table-and-language-system-record).
#[derive(Clone, Copy, Debug)]
pub struct Script<'a> {
/// Script tag.
pub tag: Tag,
/// Default language.
pub default_language: Option>,
/// List of supported languages, excluding the default one. Listed alphabetically.
pub languages: LanguageSystemList<'a>,
}
impl<'a> RecordListItem<'a> for Script<'a> {
fn parse(tag: Tag, data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
let mut default_language = None;
if let Some(offset) = s.read::>()? {
default_language =
LanguageSystem::parse(Tag::from_bytes(b"dflt"), data.get(offset.to_usize()..)?);
}
let mut languages = RecordList::parse(s.tail()?)?;
// Offsets are relative to this table.
languages.data = data;
Some(Self {
tag,
default_language,
languages,
})
}
}
/// A [Language System Table](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#language-system-table).
#[derive(Clone, Copy, Debug)]
pub struct LanguageSystem<'a> {
/// Language tag.
pub tag: Tag,
/// Index of a feature required for this language system.
pub required_feature: Option,
/// Array of indices into the FeatureList, in arbitrary order.
pub feature_indices: LazyArray16<'a, FeatureIndex>,
}
impl<'a> RecordListItem<'a> for LanguageSystem<'a> {
fn parse(tag: Tag, data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
let _lookup_order = s.read::()?; // Unsupported.
let required_feature = match s.read::()? {
0xFFFF => None,
v => Some(v),
};
let count = s.read::()?;
let feature_indices = s.read_array16(count)?;
Some(Self {
tag,
required_feature,
feature_indices,
})
}
}
/// A [Feature](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#feature-table).
#[allow(missing_docs)]
#[derive(Clone, Copy, Debug)]
pub struct Feature<'a> {
pub tag: Tag,
pub lookup_indices: LazyArray16<'a, LookupIndex>,
}
impl<'a> RecordListItem<'a> for Feature<'a> {
fn parse(tag: Tag, data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
let _params_offset = s.read::()?; // Unsupported.
let count = s.read::()?;
let lookup_indices = s.read_array16(count)?;
Some(Self {
tag,
lookup_indices,
})
}
}
ttf-parser-0.24.1/src/ggg/lookup.rs 0000644 0000000 0000000 00000011401 10461020230 0015206 0 ustar 0000000 0000000 use crate::parser::{
FromData, FromSlice, LazyArray16, LazyOffsetArray16, Offset, Offset16, Offset32, Stream,
};
/// A list of [`Lookup`] values.
pub type LookupList<'a> = LazyOffsetArray16<'a, Lookup<'a>>;
/// A [Lookup Table](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#lookup-table).
#[derive(Clone, Copy, Debug)]
pub struct Lookup<'a> {
/// Lookup qualifiers.
pub flags: LookupFlags,
/// Available subtables.
pub subtables: LookupSubtables<'a>,
/// Index into GDEF mark glyph sets structure.
pub mark_filtering_set: Option,
}
impl<'a> FromSlice<'a> for Lookup<'a> {
fn parse(data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
let kind = s.read::()?;
let flags = s.read::()?;
let count = s.read::()?;
let offsets = s.read_array16(count)?;
let mut mark_filtering_set: Option = None;
if flags.use_mark_filtering_set() {
mark_filtering_set = Some(s.read::()?);
}
Some(Self {
flags,
subtables: LookupSubtables {
kind,
data,
offsets,
},
mark_filtering_set,
})
}
}
/// A trait for parsing Lookup subtables.
///
/// Internal use only.
pub trait LookupSubtable<'a>: Sized {
/// Parses raw data.
fn parse(data: &'a [u8], kind: u16) -> Option;
}
/// A list of lookup subtables.
#[derive(Clone, Copy)]
pub struct LookupSubtables<'a> {
kind: u16,
data: &'a [u8],
offsets: LazyArray16<'a, Offset16>,
}
impl core::fmt::Debug for LookupSubtables<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
write!(f, "LookupSubtables {{ ... }}")
}
}
impl<'a> LookupSubtables<'a> {
/// Returns a number of items in the LookupSubtables.
#[inline]
pub fn len(&self) -> u16 {
self.offsets.len()
}
/// Checks if there are any items.
pub fn is_empty(&self) -> bool {
self.offsets.is_empty()
}
/// Parses a subtable at index.
///
/// Accepts either
/// [`PositioningSubtable`](crate::gpos::PositioningSubtable)
/// or [`SubstitutionSubtable`](crate::gsub::SubstitutionSubtable).
///
/// Technically, we can enforce it at compile time, but it makes code too convoluted.
pub fn get>(&self, index: u16) -> Option {
let offset = self.offsets.get(index)?.to_usize();
let data = self.data.get(offset..)?;
T::parse(data, self.kind)
}
/// Creates an iterator over subtables.
///
/// We cannot use `IntoIterator` here, because we have to use user-provided base type.
#[allow(clippy::should_implement_trait)]
pub fn into_iter>(self) -> LookupSubtablesIter<'a, T> {
LookupSubtablesIter {
data: self,
index: 0,
data_type: core::marker::PhantomData,
}
}
}
/// An iterator over lookup subtables.
#[allow(missing_debug_implementations)]
pub struct LookupSubtablesIter<'a, T: LookupSubtable<'a>> {
data: LookupSubtables<'a>,
index: u16,
data_type: core::marker::PhantomData,
}
impl<'a, T: LookupSubtable<'a>> Iterator for LookupSubtablesIter<'a, T> {
type Item = T;
fn next(&mut self) -> Option {
if self.index < self.data.len() {
self.index += 1;
self.data.get(self.index - 1)
} else {
None
}
}
}
/// Lookup table flags.
#[allow(missing_docs)]
#[derive(Clone, Copy, Debug)]
pub struct LookupFlags(pub u16);
#[rustfmt::skip]
#[allow(missing_docs)]
impl LookupFlags {
#[inline] pub fn right_to_left(self) -> bool { self.0 & 0x0001 != 0 }
#[inline] pub fn ignore_base_glyphs(self) -> bool { self.0 & 0x0002 != 0 }
#[inline] pub fn ignore_ligatures(self) -> bool { self.0 & 0x0004 != 0 }
#[inline] pub fn ignore_marks(self) -> bool { self.0 & 0x0008 != 0 }
#[inline] pub fn ignore_flags(self) -> bool { self.0 & 0x000E != 0 }
#[inline] pub fn use_mark_filtering_set(self) -> bool { self.0 & 0x0010 != 0 }
#[inline] pub fn mark_attachment_type(self) -> u8 { ((self.0 & 0xFF00) >> 8) as u8 }
}
impl FromData for LookupFlags {
const SIZE: usize = 2;
#[inline]
fn parse(data: &[u8]) -> Option {
u16::parse(data).map(Self)
}
}
pub(crate) fn parse_extension_lookup<'a, T: 'a>(
data: &'a [u8],
parse: impl FnOnce(&'a [u8], u16) -> Option,
) -> Option {
let mut s = Stream::new(data);
let format = s.read::()?;
match format {
1 => {
let kind = s.read::()?;
let offset = s.read::()?.to_usize();
parse(data.get(offset..)?, kind)
}
_ => None,
}
}
ttf-parser-0.24.1/src/ggg/mod.rs 0000644 0000000 0000000 00000011614 10461020230 0014462 0 ustar 0000000 0000000 //! Common data types used by GDEF/GPOS/GSUB tables.
//!
//!
// A heavily modified port of https://github.com/RazrFalcon/rustybuzz implementation
// originally written by https://github.com/laurmaedje
use crate::parser::{FromData, FromSlice, LazyArray16, Stream};
use crate::GlyphId;
mod chained_context;
mod context;
#[cfg(feature = "variable-fonts")]
mod feature_variations;
mod layout_table;
mod lookup;
pub use chained_context::*;
pub use context::*;
#[cfg(feature = "variable-fonts")]
pub use feature_variations::*;
pub use layout_table::*;
pub use lookup::*;
/// A record that describes a range of glyph IDs.
#[derive(Clone, Copy, Debug)]
pub struct RangeRecord {
/// First glyph ID in the range
pub start: GlyphId,
/// Last glyph ID in the range
pub end: GlyphId,
/// Coverage Index of first glyph ID in range.
pub value: u16,
}
impl LazyArray16<'_, RangeRecord> {
/// Returns a [`RangeRecord`] for a glyph.
pub fn range(&self, glyph: GlyphId) -> Option {
self.binary_search_by(|record| {
if glyph < record.start {
core::cmp::Ordering::Greater
} else if glyph <= record.end {
core::cmp::Ordering::Equal
} else {
core::cmp::Ordering::Less
}
})
.map(|p| p.1)
}
}
impl FromData for RangeRecord {
const SIZE: usize = 6;
#[inline]
fn parse(data: &[u8]) -> Option {
let mut s = Stream::new(data);
Some(RangeRecord {
start: s.read::()?,
end: s.read::()?,
value: s.read::()?,
})
}
}
/// A [Coverage Table](
/// https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#coverage-table).
#[allow(missing_docs)]
#[derive(Clone, Copy, Debug)]
pub enum Coverage<'a> {
Format1 {
/// Array of glyph IDs. Sorted.
glyphs: LazyArray16<'a, GlyphId>,
},
Format2 {
/// Array of glyph ranges. Ordered by `RangeRecord.start`.
records: LazyArray16<'a, RangeRecord>,
},
}
impl<'a> FromSlice<'a> for Coverage<'a> {
fn parse(data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
match s.read::()? {
1 => {
let count = s.read::()?;
let glyphs = s.read_array16(count)?;
Some(Self::Format1 { glyphs })
}
2 => {
let count = s.read::()?;
let records = s.read_array16(count)?;
Some(Self::Format2 { records })
}
_ => None,
}
}
}
impl<'a> Coverage<'a> {
/// Checks that glyph is present.
pub fn contains(&self, glyph: GlyphId) -> bool {
self.get(glyph).is_some()
}
/// Returns the coverage index of the glyph or `None` if it is not covered.
pub fn get(&self, glyph: GlyphId) -> Option {
match self {
Self::Format1 { glyphs } => glyphs.binary_search(&glyph).map(|p| p.0),
Self::Format2 { records } => {
let record = records.range(glyph)?;
let offset = glyph.0 - record.start.0;
record.value.checked_add(offset)
}
}
}
}
/// A value of [Class Definition Table](
/// https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#class-definition-table).
pub type Class = u16;
/// A [Class Definition Table](
/// https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#class-definition-table).
#[allow(missing_docs)]
#[derive(Clone, Copy, Debug)]
pub enum ClassDefinition<'a> {
Format1 {
start: GlyphId,
classes: LazyArray16<'a, Class>,
},
Format2 {
records: LazyArray16<'a, RangeRecord>,
},
Empty,
}
impl<'a> ClassDefinition<'a> {
#[inline]
pub(crate) fn parse(data: &'a [u8]) -> Option {
let mut s = Stream::new(data);
match s.read::()? {
1 => {
let start = s.read::()?;
let count = s.read::()?;
let classes = s.read_array16(count)?;
Some(Self::Format1 { start, classes })
}
2 => {
let count = s.read::()?;
let records = s.read_array16(count)?;
Some(Self::Format2 { records })
}
_ => None,
}
}
/// Returns the glyph class of the glyph (zero if it is not defined).
pub fn get(&self, glyph: GlyphId) -> Class {
match self {
Self::Format1 { start, classes } => glyph
.0
.checked_sub(start.0)
.and_then(|index| classes.get(index)),
Self::Format2 { records } => records.range(glyph).map(|record| record.value),
Self::Empty => Some(0),
}
.unwrap_or(0)
}
}
ttf-parser-0.24.1/src/language.rs 0000644 0000000 0000000 00000046603 10461020230 0014730 0 ustar 0000000 0000000 #[rustfmt::skip]
static TABLE: &[(u16, Language, &str, &str)] = &[
(0x0000, Language::Unknown, "Unknown", "Unknown"),
(0x0436, Language::Afrikaans_SouthAfrica, "Afrikaans", "South Africa"),
(0x041C, Language::Albanian_Albania, "Albanian", "Albania"),
(0x0484, Language::Alsatian_France, "Alsatian", "France"),
(0x045E, Language::Amharic_Ethiopia, "Amharic", "Ethiopia"),
(0x1401, Language::Arabic_Algeria, "Arabic", "Algeria"),
(0x3C01, Language::Arabic_Bahrain, "Arabic", "Bahrain"),
(0x0C01, Language::Arabic_Egypt, "Arabic", "Egypt"),
(0x0801, Language::Arabic_Iraq, "Arabic", "Iraq"),
(0x2C01, Language::Arabic_Jordan, "Arabic", "Jordan"),
(0x3401, Language::Arabic_Kuwait, "Arabic", "Kuwait"),
(0x3001, Language::Arabic_Lebanon, "Arabic", "Lebanon"),
(0x1001, Language::Arabic_Libya, "Arabic", "Libya"),
(0x1801, Language::Arabic_Morocco, "Arabic", "Morocco"),
(0x2001, Language::Arabic_Oman, "Arabic", "Oman"),
(0x4001, Language::Arabic_Qatar, "Arabic", "Qatar"),
(0x0401, Language::Arabic_SaudiArabia, "Arabic", "Saudi Arabia"),
(0x2801, Language::Arabic_Syria, "Arabic", "Syria"),
(0x1C01, Language::Arabic_Tunisia, "Arabic", "Tunisia"),
(0x3801, Language::Arabic_UAE, "Arabic", "U.A.E."),
(0x2401, Language::Arabic_Yemen, "Arabic", "Yemen"),
(0x042B, Language::Armenian_Armenia, "Armenian", "Armenia"),
(0x044D, Language::Assamese_India, "Assamese", "India"),
(0x082C, Language::Azeri_Cyrillic_Azerbaijan, "Azeri (Cyrillic)", "Azerbaijan"),
(0x042C, Language::Azeri_Latin_Azerbaijan, "Azeri (Latin)", "Azerbaijan"),
(0x046D, Language::Bashkir_Russia, "Bashkir", "Russia"),
(0x042D, Language::Basque_Basque, "Basque", "Basque"),
(0x0423, Language::Belarusian_Belarus, "Belarusian", "Belarus"),
(0x0845, Language::Bengali_Bangladesh, "Bengali", "Bangladesh"),
(0x0445, Language::Bengali_India, "Bengali", "India"),
(0x201A, Language::Bosnian_Cyrillic_BosniaAndHerzegovina, "Bosnian (Cyrillic)", "Bosnia and Herzegovina"),
(0x141A, Language::Bosnian_Latin_BosniaAndHerzegovina, "Bosnian (Latin)", "Bosnia and Herzegovina"),
(0x047E, Language::Breton_France, "Breton", "France"),
(0x0402, Language::Bulgarian_Bulgaria, "Bulgarian", "Bulgaria"),
(0x0403, Language::Catalan_Catalan, "Catalan", "Catalan"),
(0x0C04, Language::Chinese_HongKongSAR, "Chinese", "Hong Kong S.A.R."),
(0x1404, Language::Chinese_MacaoSAR, "Chinese", "Macao S.A.R."),
(0x0804, Language::Chinese_PeoplesRepublicOfChina, "Chinese", "People's Republic of China"),
(0x1004, Language::Chinese_Singapore, "Chinese", "Singapore"),
(0x0404, Language::Chinese_Taiwan, "Chinese", "Taiwan"),
(0x0483, Language::Corsican_France, "Corsican", "France"),
(0x041A, Language::Croatian_Croatia, "Croatian", "Croatia"),
(0x101A, Language::Croatian_Latin_BosniaAndHerzegovina, "Croatian (Latin)", "Bosnia and Herzegovina"),
(0x0405, Language::Czech_CzechRepublic, "Czech", "Czech Republic"),
(0x0406, Language::Danish_Denmark, "Danish", "Denmark"),
(0x048C, Language::Dari_Afghanistan, "Dari", "Afghanistan"),
(0x0465, Language::Divehi_Maldives, "Divehi", "Maldives"),
(0x0813, Language::Dutch_Belgium, "Dutch", "Belgium"),
(0x0413, Language::Dutch_Netherlands, "Dutch", "Netherlands"),
(0x0C09, Language::English_Australia, "English", "Australia"),
(0x2809, Language::English_Belize, "English", "Belize"),
(0x1009, Language::English_Canada, "English", "Canada"),
(0x2409, Language::English_Caribbean, "English", "Caribbean"),
(0x4009, Language::English_India, "English", "India"),
(0x1809, Language::English_Ireland, "English", "Ireland"),
(0x2009, Language::English_Jamaica, "English", "Jamaica"),
(0x4409, Language::English_Malaysia, "English", "Malaysia"),
(0x1409, Language::English_NewZealand, "English", "New Zealand"),
(0x3409, Language::English_RepublicOfThePhilippines, "English", "Republic of the Philippines"),
(0x4809, Language::English_Singapore, "English", "Singapore"),
(0x1C09, Language::English_SouthAfrica, "English", "South Africa"),
(0x2C09, Language::English_TrinidadAndTobago, "English", "Trinidad and Tobago"),
(0x0809, Language::English_UnitedKingdom, "English", "United Kingdom"),
(0x0409, Language::English_UnitedStates, "English", "United States"),
(0x3009, Language::English_Zimbabwe, "English", "Zimbabwe"),
(0x0425, Language::Estonian_Estonia, "Estonian", "Estonia"),
(0x0438, Language::Faroese_FaroeIslands, "Faroese", "Faroe Islands"),
(0x0464, Language::Filipino_Philippines, "Filipino", "Philippines"),
(0x040B, Language::Finnish_Finland, "Finnish", "Finland"),
(0x080C, Language::French_Belgium, "French", "Belgium"),
(0x0C0C, Language::French_Canada, "French", "Canada"),
(0x040C, Language::French_France, "French", "France"),
(0x140c, Language::French_Luxembourg, "French", "Luxembourg"),
(0x180C, Language::French_PrincipalityOfMonaco, "French", "Principality of Monaco"),
(0x100C, Language::French_Switzerland, "French", "Switzerland"),
(0x0462, Language::Frisian_Netherlands, "Frisian", "Netherlands"),
(0x0456, Language::Galician_Galician, "Galician", "Galician"),
(0x0437, Language::Georgian_Georgia, "Georgian", "Georgia"),
(0x0C07, Language::German_Austria, "German", "Austria"),
(0x0407, Language::German_Germany, "German", "Germany"),
(0x1407, Language::German_Liechtenstein, "German", "Liechtenstein"),
(0x1007, Language::German_Luxembourg, "German", "Luxembourg"),
(0x0807, Language::German_Switzerland, "German", "Switzerland"),
(0x0408, Language::Greek_Greece, "Greek", "Greece"),
(0x046F, Language::Greenlandic_Greenland, "Greenlandic", "Greenland"),
(0x0447, Language::Gujarati_India, "Gujarati", "India"),
(0x0468, Language::Hausa_Latin_Nigeria, "Hausa (Latin)", "Nigeria"),
(0x040D, Language::Hebrew_Israel, "Hebrew", "Israel"),
(0x0439, Language::Hindi_India, "Hindi", "India"),
(0x040E, Language::Hungarian_Hungary, "Hungarian", "Hungary"),
(0x040F, Language::Icelandic_Iceland, "Icelandic", "Iceland"),
(0x0470, Language::Igbo_Nigeria, "Igbo", "Nigeria"),
(0x0421, Language::Indonesian_Indonesia, "Indonesian", "Indonesia"),
(0x045D, Language::Inuktitut_Canada, "Inuktitut", "Canada"),
(0x085D, Language::Inuktitut_Latin_Canada, "Inuktitut (Latin)", "Canada"),
(0x083C, Language::Irish_Ireland, "Irish", "Ireland"),
(0x0434, Language::isiXhosa_SouthAfrica, "isiXhosa", "South Africa"),
(0x0435, Language::isiZulu_SouthAfrica, "isiZulu", "South Africa"),
(0x0410, Language::Italian_Italy, "Italian", "Italy"),
(0x0810, Language::Italian_Switzerland, "Italian", "Switzerland"),
(0x0411, Language::Japanese_Japan, "Japanese", "Japan"),
(0x044B, Language::Kannada_India, "Kannada", "India"),
(0x043F, Language::Kazakh_Kazakhstan, "Kazakh", "Kazakhstan"),
(0x0453, Language::Khmer_Cambodia, "Khmer", "Cambodia"),
(0x0486, Language::Kiche_Guatemala, "K'iche", "Guatemala"),
(0x0487, Language::Kinyarwanda_Rwanda, "Kinyarwanda", "Rwanda"),
(0x0441, Language::Kiswahili_Kenya, "Kiswahili", "Kenya"),
(0x0457, Language::Konkani_India, "Konkani", "India"),
(0x0412, Language::Korean_Korea, "Korean", "Korea"),
(0x0440, Language::Kyrgyz_Kyrgyzstan, "Kyrgyz", "Kyrgyzstan"),
(0x0454, Language::Lao_LaoPDR, "Lao", "Lao P.D.R."),
(0x0426, Language::Latvian_Latvia, "Latvian", "Latvia"),
(0x0427, Language::Lithuanian_Lithuania, "Lithuanian", "Lithuania"),
(0x082E, Language::LowerSorbian_Germany, "Lower Sorbian", "Germany"),
(0x046E, Language::Luxembourgish_Luxembourg, "Luxembourgish", "Luxembourg"),
(0x042F, Language::Macedonian_NorthMacedonia, "Macedonian", "North Macedonia"),
(0x083E, Language::Malay_BruneiDarussalam, "Malay", "Brunei Darussalam"),
(0x043E, Language::Malay_Malaysia, "Malay", "Malaysia"),
(0x044C, Language::Malayalam_India, "Malayalam", "India"),
(0x043A, Language::Maltese_Malta, "Maltese", "Malta"),
(0x0481, Language::Maori_NewZealand, "Maori", "New Zealand"),
(0x047A, Language::Mapudungun_Chile, "Mapudungun", "Chile"),
(0x044E, Language::Marathi_India, "Marathi", "India"),
(0x047C, Language::Mohawk_Mohawk, "Mohawk", "Mohawk"),
(0x0450, Language::Mongolian_Cyrillic_Mongolia, "Mongolian (Cyrillic)", "Mongolia"),
(0x0850, Language::Mongolian_Traditional_PeoplesRepublicOfChina, "Mongolian (Traditional)", "People's Republic of China"),
(0x0461, Language::Nepali_Nepal, "Nepali", "Nepal"),
(0x0414, Language::Norwegian_Bokmal_Norway, "Norwegian (Bokmal)", "Norway"),
(0x0814, Language::Norwegian_Nynorsk_Norway, "Norwegian (Nynorsk)", "Norway"),
(0x0482, Language::Occitan_France, "Occitan", "France"),
(0x0448, Language::Odia_India, "Odia (formerly Oriya)", "India"),
(0x0463, Language::Pashto_Afghanistan, "Pashto", "Afghanistan"),
(0x0415, Language::Polish_Poland, "Polish", "Poland"),
(0x0416, Language::Portuguese_Brazil, "Portuguese", "Brazil"),
(0x0816, Language::Portuguese_Portugal, "Portuguese", "Portugal"),
(0x0446, Language::Punjabi_India, "Punjabi", "India"),
(0x046B, Language::Quechua_Bolivia, "Quechua", "Bolivia"),
(0x086B, Language::Quechua_Ecuador, "Quechua", "Ecuador"),
(0x0C6B, Language::Quechua_Peru, "Quechua", "Peru"),
(0x0418, Language::Romanian_Romania, "Romanian", "Romania"),
(0x0417, Language::Romansh_Switzerland, "Romansh", "Switzerland"),
(0x0419, Language::Russian_Russia, "Russian", "Russia"),
(0x243B, Language::Sami_Inari_Finland, "Sami (Inari)", "Finland"),
(0x103B, Language::Sami_Lule_Norway, "Sami (Lule)", "Norway"),
(0x143B, Language::Sami_Lule_Sweden, "Sami (Lule)", "Sweden"),
(0x0C3B, Language::Sami_Northern_Finland, "Sami (Northern)", "Finland"),
(0x043B, Language::Sami_Northern_Norway, "Sami (Northern)", "Norway"),
(0x083B, Language::Sami_Northern_Sweden, "Sami (Northern)", "Sweden"),
(0x203B, Language::Sami_Skolt_Finland, "Sami (Skolt)", "Finland"),
(0x183B, Language::Sami_Southern_Norway, "Sami (Southern)", "Norway"),
(0x1C3B, Language::Sami_Southern_Sweden, "Sami (Southern)", "Sweden"),
(0x044F, Language::Sanskrit_India, "Sanskrit", "India"),
(0x1C1A, Language::Serbian_Cyrillic_BosniaAndHerzegovina, "Serbian (Cyrillic)", "Bosnia and Herzegovina"),
(0x0C1A, Language::Serbian_Cyrillic_Serbia, "Serbian (Cyrillic)", "Serbia"),
(0x181A, Language::Serbian_Latin_BosniaAndHerzegovina, "Serbian (Latin)", "Bosnia and Herzegovina"),
(0x081A, Language::Serbian_Latin_Serbia, "Serbian (Latin)", "Serbia"),
(0x046C, Language::SesothoSaLeboa_SouthAfrica, "Sesotho sa Leboa", "South Africa"),
(0x0432, Language::Setswana_SouthAfrica, "Setswana", "South Africa"),
(0x045B, Language::Sinhala_SriLanka, "Sinhala", "Sri Lanka"),
(0x041B, Language::Slovak_Slovakia, "Slovak", "Slovakia"),
(0x0424, Language::Slovenian_Slovenia, "Slovenian", "Slovenia"),
(0x2C0A, Language::Spanish_Argentina, "Spanish", "Argentina"),
(0x400A, Language::Spanish_Bolivia, "Spanish", "Bolivia"),
(0x340A, Language::Spanish_Chile, "Spanish", "Chile"),
(0x240A, Language::Spanish_Colombia, "Spanish", "Colombia"),
(0x140A, Language::Spanish_CostaRica, "Spanish", "Costa Rica"),
(0x1C0A, Language::Spanish_DominicanRepublic, "Spanish", "Dominican Republic"),
(0x300A, Language::Spanish_Ecuador, "Spanish", "Ecuador"),
(0x440A, Language::Spanish_ElSalvador, "Spanish", "El Salvador"),
(0x100A, Language::Spanish_Guatemala, "Spanish", "Guatemala"),
(0x480A, Language::Spanish_Honduras, "Spanish", "Honduras"),
(0x080A, Language::Spanish_Mexico, "Spanish", "Mexico"),
(0x4C0A, Language::Spanish_Nicaragua, "Spanish", "Nicaragua"),
(0x180A, Language::Spanish_Panama, "Spanish", "Panama"),
(0x3C0A, Language::Spanish_Paraguay, "Spanish", "Paraguay"),
(0x280A, Language::Spanish_Peru, "Spanish", "Peru"),
(0x500A, Language::Spanish_PuertoRico, "Spanish", "Puerto Rico"),
(0x0C0A, Language::Spanish_ModernSort_Spain, "Spanish (Modern Sort)", "Spain"),
(0x040A, Language::Spanish_TraditionalSort_Spain, "Spanish (Traditional Sort)", "Spain"),
(0x540A, Language::Spanish_UnitedStates, "Spanish", "United States"),
(0x380A, Language::Spanish_Uruguay, "Spanish", "Uruguay"),
(0x200A, Language::Spanish_Venezuela, "Spanish", "Venezuela"),
(0x081D, Language::Swedish_Finland, "Swedish", "Finland"),
(0x041D, Language::Swedish_Sweden, "Swedish", "Sweden"),
(0x045A, Language::Syriac_Syria, "Syriac", "Syria"),
(0x0428, Language::Tajik_Cyrillic_Tajikistan, "Tajik (Cyrillic)", "Tajikistan"),
(0x085F, Language::Tamazight_Latin_Algeria, "Tamazight (Latin)", "Algeria"),
(0x0449, Language::Tamil_India, "Tamil", "India"),
(0x0444, Language::Tatar_Russia, "Tatar", "Russia"),
(0x044A, Language::Telugu_India, "Telugu", "India"),
(0x041E, Language::Thai_Thailand, "Thai", "Thailand"),
(0x0451, Language::Tibetan_PRC, "Tibetan", "PRC"),
(0x041F, Language::Turkish_Turkey, "Turkish", "Turkey"),
(0x0442, Language::Turkmen_Turkmenistan, "Turkmen", "Turkmenistan"),
(0x0480, Language::Uighur_PRC, "Uighur", "PRC"),
(0x0422, Language::Ukrainian_Ukraine, "Ukrainian", "Ukraine"),
(0x042E, Language::UpperSorbian_Germany, "Upper Sorbian", "Germany"),
(0x0420, Language::Urdu_IslamicRepublicOfPakistan, "Urdu", "Islamic Republic of Pakistan"),
(0x0843, Language::Uzbek_Cyrillic_Uzbekistan, "Uzbek (Cyrillic)", "Uzbekistan"),
(0x0443, Language::Uzbek_Latin_Uzbekistan, "Uzbek (Latin)", "Uzbekistan"),
(0x042A, Language::Vietnamese_Vietnam, "Vietnamese", "Vietnam"),
(0x0452, Language::Welsh_UnitedKingdom, "Welsh", "United Kingdom"),
(0x0488, Language::Wolof_Senegal, "Wolof", "Senegal"),
(0x0485, Language::Yakut_Russia, "Yakut", "Russia"),
(0x0478, Language::Yi_PRC, "Yi", "PRC"),
(0x046A, Language::Yoruba_Nigeria, "Yoruba", "Nigeria"),
];
/// A [`Name`](crate::name::Name) language.
///
/// Consists of Language + Region pairs.
///
///
#[allow(missing_docs)]
#[allow(non_camel_case_types)]
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Language {
Unknown = 0,
Afrikaans_SouthAfrica,
Albanian_Albania,
Alsatian_France,
Amharic_Ethiopia,
Arabic_Algeria,
Arabic_Bahrain,
Arabic_Egypt,
Arabic_Iraq,
Arabic_Jordan,
Arabic_Kuwait,
Arabic_Lebanon,
Arabic_Libya,
Arabic_Morocco,
Arabic_Oman,
Arabic_Qatar,
Arabic_SaudiArabia,
Arabic_Syria,
Arabic_Tunisia,
Arabic_UAE,
Arabic_Yemen,
Armenian_Armenia,
Assamese_India,
Azeri_Cyrillic_Azerbaijan,
Azeri_Latin_Azerbaijan,
Bashkir_Russia,
Basque_Basque,
Belarusian_Belarus,
Bengali_Bangladesh,
Bengali_India,
Bosnian_Cyrillic_BosniaAndHerzegovina,
Bosnian_Latin_BosniaAndHerzegovina,
Breton_France,
Bulgarian_Bulgaria,
Catalan_Catalan,
Chinese_HongKongSAR,
Chinese_MacaoSAR,
Chinese_PeoplesRepublicOfChina,
Chinese_Singapore,
Chinese_Taiwan,
Corsican_France,
Croatian_Croatia,
Croatian_Latin_BosniaAndHerzegovina,
Czech_CzechRepublic,
Danish_Denmark,
Dari_Afghanistan,
Divehi_Maldives,
Dutch_Belgium,
Dutch_Netherlands,
English_Australia,
English_Belize,
English_Canada,
English_Caribbean,
English_India,
English_Ireland,
English_Jamaica,
English_Malaysia,
English_NewZealand,
English_RepublicOfThePhilippines,
English_Singapore,
English_SouthAfrica,
English_TrinidadAndTobago,
English_UnitedKingdom,
English_UnitedStates,
English_Zimbabwe,
Estonian_Estonia,
Faroese_FaroeIslands,
Filipino_Philippines,
Finnish_Finland,
French_Belgium,
French_Canada,
French_France,
French_Luxembourg,
French_PrincipalityOfMonaco,
French_Switzerland,
Frisian_Netherlands,
Galician_Galician,
Georgian_Georgia,
German_Austria,
German_Germany,
German_Liechtenstein,
German_Luxembourg,
German_Switzerland,
Greek_Greece,
Greenlandic_Greenland,
Gujarati_India,
Hausa_Latin_Nigeria,
Hebrew_Israel,
Hindi_India,
Hungarian_Hungary,
Icelandic_Iceland,
Igbo_Nigeria,
Indonesian_Indonesia,
Inuktitut_Canada,
Inuktitut_Latin_Canada,
Irish_Ireland,
isiXhosa_SouthAfrica,
isiZulu_SouthAfrica,
Italian_Italy,
Italian_Switzerland,
Japanese_Japan,
Kannada_India,
Kazakh_Kazakhstan,
Khmer_Cambodia,
Kiche_Guatemala,
Kinyarwanda_Rwanda,
Kiswahili_Kenya,
Konkani_India,
Korean_Korea,
Kyrgyz_Kyrgyzstan,
Lao_LaoPDR,
Latvian_Latvia,
Lithuanian_Lithuania,
LowerSorbian_Germany,
Luxembourgish_Luxembourg,
Macedonian_NorthMacedonia,
Malay_BruneiDarussalam,
Malay_Malaysia,
Malayalam_India,
Maltese_Malta,
Maori_NewZealand,
Mapudungun_Chile,
Marathi_India,
Mohawk_Mohawk,
Mongolian_Cyrillic_Mongolia,
Mongolian_Traditional_PeoplesRepublicOfChina,
Nepali_Nepal,
Norwegian_Bokmal_Norway,
Norwegian_Nynorsk_Norway,
Occitan_France,
Odia_India,
Pashto_Afghanistan,
Polish_Poland,
Portuguese_Brazil,
Portuguese_Portugal,
Punjabi_India,
Quechua_Bolivia,
Quechua_Ecuador,
Quechua_Peru,
Romanian_Romania,
Romansh_Switzerland,
Russian_Russia,
Sami_Inari_Finland,
Sami_Lule_Norway,
Sami_Lule_Sweden,
Sami_Northern_Finland,
Sami_Northern_Norway,
Sami_Northern_Sweden,
Sami_Skolt_Finland,
Sami_Southern_Norway,
Sami_Southern_Sweden,
Sanskrit_India,
Serbian_Cyrillic_BosniaAndHerzegovina,
Serbian_Cyrillic_Serbia,
Serbian_Latin_BosniaAndHerzegovina,
Serbian_Latin_Serbia,
SesothoSaLeboa_SouthAfrica,
Setswana_SouthAfrica,
Sinhala_SriLanka,
Slovak_Slovakia,
Slovenian_Slovenia,
Spanish_Argentina,
Spanish_Bolivia,
Spanish_Chile,
Spanish_Colombia,
Spanish_CostaRica,
Spanish_DominicanRepublic,
Spanish_Ecuador,
Spanish_ElSalvador,
Spanish_Guatemala,
Spanish_Honduras,
Spanish_Mexico,
Spanish_Nicaragua,
Spanish_Panama,
Spanish_Paraguay,
Spanish_Peru,
Spanish_PuertoRico,
Spanish_ModernSort_Spain,
Spanish_TraditionalSort_Spain,
Spanish_UnitedStates,
Spanish_Uruguay,
Spanish_Venezuela,
Swedish_Finland,
Swedish_Sweden,
Syriac_Syria,
Tajik_Cyrillic_Tajikistan,
Tamazight_Latin_Algeria,
Tamil_India,
Tatar_Russia,
Telugu_India,
Thai_Thailand,
Tibetan_PRC,
Turkish_Turkey,
Turkmen_Turkmenistan,
Uighur_PRC,
Ukrainian_Ukraine,
UpperSorbian_Germany,
Urdu_IslamicRepublicOfPakistan,
Uzbek_Cyrillic_Uzbekistan,
Uzbek_Latin_Uzbekistan,
Vietnamese_Vietnam,
Welsh_UnitedKingdom,
Wolof_Senegal,
Yakut_Russia,
Yi_PRC,
Yoruba_Nigeria,
}
impl Language {
pub(crate) fn windows_language(id: u16) -> Self {
if let Some(index) = TABLE.iter().position(|v| v.0 == id) {
TABLE[index].1
} else {
Self::Unknown
}
}
/// Returns the primary language.
pub fn primary_language(&self) -> &'static str {
TABLE[*self as usize].2
}
/// Returns a language region.
pub fn region(&self) -> &'static str {
TABLE[*self as usize].3
}
}
impl core::fmt::Display for Language {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{} ({})", self.primary_language(), self.region())
}
}
ttf-parser-0.24.1/src/lib.rs 0000644 0000000 0000000 00000233674 10461020230 0013721 0 ustar 0000000 0000000 /*!
A high-level, safe, zero-allocation font parser for:
* [TrueType](https://docs.microsoft.com/en-us/typography/truetype/),
* [OpenType](https://docs.microsoft.com/en-us/typography/opentype/spec/), and
* [AAT](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6AATIntro.html)
fonts.
Font parsing starts with a [`Face`].
## Features
- A high-level API for most common properties, hiding all parsing and data resolving logic.
- A low-level, but safe API to access TrueType tables data.
- Highly configurable. You can disable most of the features, reducing binary size.
You can also parse TrueType tables separately, without loading the whole font/face.
- Zero heap allocations.
- Zero unsafe.
- Zero dependencies.
- `no_std`/WASM compatible.
- Fast.
- Stateless. All parsing methods are immutable.
- Simple and maintainable code (no magic numbers).
## Safety
- The library must not panic. Any panic considered as a critical bug and should be reported.
- The library forbids unsafe code.
- No heap allocations, so crash due to OOM is not possible.
- All recursive methods have a depth limit.
- Technically, should use less than 64KiB of stack in worst case scenario.
- Most of arithmetic operations are checked.
- Most of numeric casts are checked.
*/
#![no_std]
#![forbid(unsafe_code)]
#![warn(missing_docs)]
#![warn(missing_copy_implementations)]
#![warn(missing_debug_implementations)]
#![allow(clippy::get_first)] // we use it for readability
#![allow(clippy::identity_op)] // we use it for readability
#![allow(clippy::too_many_arguments)]
#![allow(clippy::collapsible_else_if)]
#![allow(clippy::field_reassign_with_default)]
#![allow(clippy::upper_case_acronyms)]
#![allow(clippy::bool_assert_comparison)]
#[cfg(feature = "std")]
#[macro_use]
extern crate std;
#[cfg(not(any(feature = "std", feature = "no-std-float")))]
compile_error!("You have to activate either the `std` or the `no-std-float` feature.");
#[cfg(not(feature = "std"))]
use core_maths::CoreFloat;
#[cfg(feature = "apple-layout")]
mod aat;
#[cfg(feature = "variable-fonts")]
mod delta_set;
#[cfg(feature = "opentype-layout")]
mod ggg;
mod language;
mod parser;
mod tables;
#[cfg(feature = "variable-fonts")]
mod var_store;
use head::IndexToLocationFormat;
pub use parser::{Fixed, FromData, LazyArray16, LazyArray32, LazyArrayIter16, LazyArrayIter32};
use parser::{NumFrom, Offset, Offset32, Stream, TryNumFrom};
#[cfg(feature = "variable-fonts")]
pub use fvar::VariationAxis;
pub use language::Language;
pub use name::{name_id, PlatformId};
pub use os2::{Permissions, ScriptMetrics, Style, UnicodeRanges, Weight, Width};
pub use tables::CFFError;
#[cfg(feature = "apple-layout")]
pub use tables::{ankr, feat, kerx, morx, trak};
#[cfg(feature = "variable-fonts")]
pub use tables::{avar, cff2, fvar, gvar, hvar, mvar, vvar};
pub use tables::{cbdt, cblc, cff1 as cff, vhea};
pub use tables::{
cmap, colr, cpal, glyf, head, hhea, hmtx, kern, loca, maxp, name, os2, post, sbix, svg, vorg,
};
#[cfg(feature = "opentype-layout")]
pub use tables::{gdef, gpos, gsub, math};
#[cfg(feature = "opentype-layout")]
pub mod opentype_layout {
//! This module contains
//! [OpenType Layout](https://docs.microsoft.com/en-us/typography/opentype/spec/chapter2#overview)
//! supplementary tables implementation.
pub use crate::ggg::*;
}
#[cfg(feature = "apple-layout")]
pub mod apple_layout {
//! This module contains
//! [Apple Advanced Typography Layout](
//! https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6AATIntro.html)
//! supplementary tables implementation.
pub use crate::aat::*;
}
/// A type-safe wrapper for glyph ID.
#[repr(transparent)]
#[derive(Clone, Copy, Ord, PartialOrd, Eq, PartialEq, Default, Debug, Hash)]
pub struct GlyphId(pub u16);
impl FromData for GlyphId {
const SIZE: usize = 2;
#[inline]
fn parse(data: &[u8]) -> Option {
u16::parse(data).map(GlyphId)
}
}
/// A TrueType font magic.
///
/// https://docs.microsoft.com/en-us/typography/opentype/spec/otff#organization-of-an-opentype-font
#[derive(Clone, Copy, PartialEq, Debug)]
enum Magic {
TrueType,
OpenType,
FontCollection,
}
impl FromData for Magic {
const SIZE: usize = 4;
#[inline]
fn parse(data: &[u8]) -> Option {
match u32::parse(data)? {
0x00010000 | 0x74727565 => Some(Magic::TrueType),
0x4F54544F => Some(Magic::OpenType),
0x74746366 => Some(Magic::FontCollection),
_ => None,
}
}
}
/// A variation coordinate in a normalized coordinate system.
///
/// Basically any number in a -1.0..1.0 range.
/// Where 0 is a default value.
///
/// The number is stored as f2.16
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, Default, Debug)]
pub struct NormalizedCoordinate(i16);
impl From for NormalizedCoordinate {
/// Creates a new coordinate.
///
/// The provided number will be clamped to the -16384..16384 range.
#[inline]
fn from(n: i16) -> Self {
NormalizedCoordinate(parser::i16_bound(-16384, n, 16384))
}
}
impl From for NormalizedCoordinate {
/// Creates a new coordinate.
///
/// The provided number will be clamped to the -1.0..1.0 range.
#[inline]
fn from(n: f32) -> Self {
NormalizedCoordinate((parser::f32_bound(-1.0, n, 1.0) * 16384.0) as i16)
}
}
impl NormalizedCoordinate {
/// Returns the coordinate value as f2.14.
#[inline]
pub fn get(self) -> i16 {
self.0
}
}
/// A font variation value.
///
/// # Example
///
/// ```
/// use ttf_parser::{Variation, Tag};
///
/// Variation { axis: Tag::from_bytes(b"wght"), value: 500.0 };
/// ```
#[derive(Clone, Copy, PartialEq, Debug)]
pub struct Variation {
/// An axis tag name.
pub axis: Tag,
/// An axis value.
pub value: f32,
}
/// A 4-byte tag.
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Tag(pub u32);
impl Tag {
/// Creates a `Tag` from bytes.
///
/// # Example
///
/// ```rust
/// println!("{}", ttf_parser::Tag::from_bytes(b"name"));
/// ```
#[inline]
pub const fn from_bytes(bytes: &[u8; 4]) -> Self {
Tag(((bytes[0] as u32) << 24)
| ((bytes[1] as u32) << 16)
| ((bytes[2] as u32) << 8)
| (bytes[3] as u32))
}
/// Creates a `Tag` from bytes.
///
/// In case of empty data will return `Tag` set to 0.
///
/// When `bytes` are shorter than 4, will set missing bytes to ` `.
///
/// Data after first 4 bytes is ignored.
#[inline]
pub fn from_bytes_lossy(bytes: &[u8]) -> Self {
if bytes.is_empty() {
return Tag::from_bytes(&[0, 0, 0, 0]);
}
let mut iter = bytes.iter().cloned().chain(core::iter::repeat(b' '));
Tag::from_bytes(&[
iter.next().unwrap(),
iter.next().unwrap(),
iter.next().unwrap(),
iter.next().unwrap(),
])
}
/// Returns tag as 4-element byte array.
#[inline]
pub const fn to_bytes(self) -> [u8; 4] {
[
(self.0 >> 24 & 0xff) as u8,
(self.0 >> 16 & 0xff) as u8,
(self.0 >> 8 & 0xff) as u8,
(self.0 >> 0 & 0xff) as u8,
]
}
/// Returns tag as 4-element byte array.
#[inline]
pub const fn to_chars(self) -> [char; 4] {
[
(self.0 >> 24 & 0xff) as u8 as char,
(self.0 >> 16 & 0xff) as u8 as char,
(self.0 >> 8 & 0xff) as u8 as char,
(self.0 >> 0 & 0xff) as u8 as char,
]
}
/// Checks if tag is null / `[0, 0, 0, 0]`.
#[inline]
pub const fn is_null(&self) -> bool {
self.0 == 0
}
/// Returns tag value as `u32` number.
#[inline]
pub const fn as_u32(&self) -> u32 {
self.0
}
}
impl core::fmt::Debug for Tag {
#[inline]
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "Tag({})", self)
}
}
impl core::fmt::Display for Tag {
#[inline]
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
let b = self.to_chars();
write!(
f,
"{}{}{}{}",
b.get(0).unwrap_or(&' '),
b.get(1).unwrap_or(&' '),
b.get(2).unwrap_or(&' '),
b.get(3).unwrap_or(&' ')
)
}
}
impl FromData for Tag {
const SIZE: usize = 4;
#[inline]
fn parse(data: &[u8]) -> Option {
u32::parse(data).map(Tag)
}
}
/// A line metrics.
///
/// Used for underline and strikeout.
#[repr(C)]
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct LineMetrics {
/// Line position.
pub position: i16,
/// Line thickness.
pub thickness: i16,
}
/// A rectangle.
///
/// Doesn't guarantee that `x_min` <= `x_max` and/or `y_min` <= `y_max`.
#[repr(C)]
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct Rect {
pub x_min: i16,
pub y_min: i16,
pub x_max: i16,
pub y_max: i16,
}
impl Rect {
#[inline]
fn zero() -> Self {
Self {
x_min: 0,
y_min: 0,
x_max: 0,
y_max: 0,
}
}
/// Returns rect's width.
#[inline]
pub fn width(&self) -> i16 {
self.x_max - self.x_min
}
/// Returns rect's height.
#[inline]
pub fn height(&self) -> i16 {
self.y_max - self.y_min
}
}
/// A rectangle described by the left-lower and upper-right points.
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct RectF {
/// The horizontal minimum of the rect.
pub x_min: f32,
/// The vertical minimum of the rect.
pub y_min: f32,
/// The horizontal maximum of the rect.
pub x_max: f32,
/// The vertical maximum of the rect.
pub y_max: f32,
}
impl RectF {
#[inline]
fn new() -> Self {
RectF {
x_min: f32::MAX,
y_min: f32::MAX,
x_max: f32::MIN,
y_max: f32::MIN,
}
}
#[inline]
fn is_default(&self) -> bool {
self.x_min == f32::MAX
&& self.y_min == f32::MAX
&& self.x_max == f32::MIN
&& self.y_max == f32::MIN
}
#[inline]
fn extend_by(&mut self, x: f32, y: f32) {
self.x_min = self.x_min.min(x);
self.y_min = self.y_min.min(y);
self.x_max = self.x_max.max(x);
self.y_max = self.y_max.max(y);
}
#[inline]
fn to_rect(self) -> Option {
Some(Rect {
x_min: i16::try_num_from(self.x_min)?,
y_min: i16::try_num_from(self.y_min)?,
x_max: i16::try_num_from(self.x_max)?,
y_max: i16::try_num_from(self.y_max)?,
})
}
}
/// An affine transform.
#[derive(Clone, Copy, PartialEq)]
pub struct Transform {
/// The 'a' component of the transform.
pub a: f32,
/// The 'b' component of the transform.
pub b: f32,
/// The 'c' component of the transform.
pub c: f32,
/// The 'd' component of the transform.
pub d: f32,
/// The 'e' component of the transform.
pub e: f32,
/// The 'f' component of the transform.
pub f: f32,
}
impl Transform {
/// Creates a new transform with the specified components.
#[inline]
pub fn new(a: f32, b: f32, c: f32, d: f32, e: f32, f: f32) -> Self {
Transform { a, b, c, d, e, f }
}
/// Creates a new translation transform.
#[inline]
pub fn new_translate(tx: f32, ty: f32) -> Self {
Transform::new(1.0, 0.0, 0.0, 1.0, tx, ty)
}
/// Creates a new rotation transform.
#[inline]
pub fn new_rotate(angle: f32) -> Self {
let cc = (angle * core::f32::consts::PI).cos();
let ss = (angle * core::f32::consts::PI).sin();
Transform::new(cc, ss, -ss, cc, 0.0, 0.0)
}
/// Creates a new skew transform.
#[inline]
pub fn new_skew(skew_x: f32, skew_y: f32) -> Self {
let x = (skew_x * core::f32::consts::PI).tan();
let y = (skew_y * core::f32::consts::PI).tan();
Transform::new(1.0, y, -x, 1.0, 0.0, 0.0)
}
/// Creates a new scale transform.
#[inline]
pub fn new_scale(sx: f32, sy: f32) -> Self {
Transform::new(sx, 0.0, 0.0, sy, 0.0, 0.0)
}
/// Combines two transforms with each other.
#[inline]
pub fn combine(ts1: Self, ts2: Self) -> Self {
Transform {
a: ts1.a * ts2.a + ts1.c * ts2.b,
b: ts1.b * ts2.a + ts1.d * ts2.b,
c: ts1.a * ts2.c + ts1.c * ts2.d,
d: ts1.b * ts2.c + ts1.d * ts2.d,
e: ts1.a * ts2.e + ts1.c * ts2.f + ts1.e,
f: ts1.b * ts2.e + ts1.d * ts2.f + ts1.f,
}
}
#[inline]
fn apply_to(&self, x: &mut f32, y: &mut f32) {
let tx = *x;
let ty = *y;
*x = self.a * tx + self.c * ty + self.e;
*y = self.b * tx + self.d * ty + self.f;
}
/// Checks whether a transform is the identity transform.
#[inline]
pub fn is_default(&self) -> bool {
// A direct float comparison is fine in our case.
self.a == 1.0
&& self.b == 0.0
&& self.c == 0.0
&& self.d == 1.0
&& self.e == 0.0
&& self.f == 0.0
}
}
impl Default for Transform {
#[inline]
fn default() -> Self {
Transform {
a: 1.0,
b: 0.0,
c: 0.0,
d: 1.0,
e: 0.0,
f: 0.0,
}
}
}
impl core::fmt::Debug for Transform {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
write!(
f,
"Transform({} {} {} {} {} {})",
self.a, self.b, self.c, self.d, self.e, self.f
)
}
}
/// A float point.
#[derive(Clone, Copy, Debug)]
pub struct PointF {
/// The X-axis coordinate.
pub x: f32,
/// The Y-axis coordinate.
pub y: f32,
}
/// Phantom points.
///
/// Available only for variable fonts with the `gvar` table.
#[derive(Clone, Copy, Debug)]
pub struct PhantomPoints {
/// Left side bearing point.
pub left: PointF,
/// Right side bearing point.
pub right: PointF,
/// Top side bearing point.
pub top: PointF,
/// Bottom side bearing point.
pub bottom: PointF,
}
/// A RGBA color in the sRGB color space.
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct RgbaColor {
pub red: u8,
pub green: u8,
pub blue: u8,
pub alpha: u8,
}
impl RgbaColor {
/// Creates a new `RgbaColor`.
#[inline]
pub fn new(red: u8, green: u8, blue: u8, alpha: u8) -> Self {
Self {
blue,
green,
red,
alpha,
}
}
pub(crate) fn apply_alpha(&mut self, alpha: f32) {
self.alpha = (((f32::from(self.alpha) / 255.0) * alpha) * 255.0) as u8;
}
}
/// A trait for glyph outline construction.
pub trait OutlineBuilder {
/// Appends a MoveTo segment.
///
/// Start of a contour.
fn move_to(&mut self, x: f32, y: f32);
/// Appends a LineTo segment.
fn line_to(&mut self, x: f32, y: f32);
/// Appends a QuadTo segment.
fn quad_to(&mut self, x1: f32, y1: f32, x: f32, y: f32);
/// Appends a CurveTo segment.
fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x: f32, y: f32);
/// Appends a ClosePath segment.
///
/// End of a contour.
fn close(&mut self);
}
struct DummyOutline;
impl OutlineBuilder for DummyOutline {
fn move_to(&mut self, _: f32, _: f32) {}
fn line_to(&mut self, _: f32, _: f32) {}
fn quad_to(&mut self, _: f32, _: f32, _: f32, _: f32) {}
fn curve_to(&mut self, _: f32, _: f32, _: f32, _: f32, _: f32, _: f32) {}
fn close(&mut self) {}
}
/// A glyph raster image format.
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum RasterImageFormat {
PNG,
/// A monochrome bitmap.
///
/// The most significant bit of the first byte corresponds to the top-left pixel, proceeding
/// through succeeding bits moving left to right. The data for each row is padded to a byte
/// boundary, so the next row begins with the most significant bit of a new byte. 1 corresponds
/// to black, and 0 to white.
BitmapMono,
/// A packed monochrome bitmap.
///
/// The most significant bit of the first byte corresponds to the top-left pixel, proceeding
/// through succeeding bits moving left to right. Data is tightly packed with no padding. 1
/// corresponds to black, and 0 to white.
BitmapMonoPacked,
/// A grayscale bitmap with 2 bits per pixel.
///
/// The most significant bits of the first byte corresponds to the top-left pixel, proceeding
/// through succeeding bits moving left to right. The data for each row is padded to a byte
/// boundary, so the next row begins with the most significant bit of a new byte.
BitmapGray2,
/// A packed grayscale bitmap with 2 bits per pixel.
///
/// The most significant bits of the first byte corresponds to the top-left pixel, proceeding
/// through succeeding bits moving left to right. Data is tightly packed with no padding.
BitmapGray2Packed,
/// A grayscale bitmap with 4 bits per pixel.
///
/// The most significant bits of the first byte corresponds to the top-left pixel, proceeding
/// through succeeding bits moving left to right. The data for each row is padded to a byte
/// boundary, so the next row begins with the most significant bit of a new byte.
BitmapGray4,
/// A packed grayscale bitmap with 4 bits per pixel.
///
/// The most significant bits of the first byte corresponds to the top-left pixel, proceeding
/// through succeeding bits moving left to right. Data is tightly packed with no padding.
BitmapGray4Packed,
/// A grayscale bitmap with 8 bits per pixel.
///
/// The first byte corresponds to the top-left pixel, proceeding through succeeding bytes
/// moving left to right.
BitmapGray8,
/// A color bitmap with 32 bits per pixel.
///
/// The first group of four bytes corresponds to the top-left pixel, proceeding through
/// succeeding pixels moving left to right. Each byte corresponds to a color channel and the
/// channels within a pixel are in blue, green, red, alpha order. Color values are
/// pre-multiplied by the alpha. For example, the color "full-green with half translucency"
/// is encoded as `\x00\x80\x00\x80`, and not `\x00\xFF\x00\x80`.
BitmapPremulBgra32,
}
/// A glyph's raster image.
///
/// Note, that glyph metrics are in pixels and not in font units.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct RasterGlyphImage<'a> {
/// Horizontal offset.
pub x: i16,
/// Vertical offset.
pub y: i16,
/// Image width.
///
/// It doesn't guarantee that this value is the same as set in the `data`.
pub width: u16,
/// Image height.
///
/// It doesn't guarantee that this value is the same as set in the `data`.
pub height: u16,
/// A pixels per em of the selected strike.
pub pixels_per_em: u16,
/// An image format.
pub format: RasterImageFormat,
/// A raw image data. It's up to the caller to decode it.
pub data: &'a [u8],
}
/// A raw table record.
#[derive(Clone, Copy, Debug)]
#[allow(missing_docs)]
pub struct TableRecord {
pub tag: Tag,
#[allow(dead_code)]
pub check_sum: u32,
pub offset: u32,
pub length: u32,
}
impl FromData for TableRecord {
const SIZE: usize = 16;
#[inline]
fn parse(data: &[u8]) -> Option {
let mut s = Stream::new(data);
Some(TableRecord {
tag: s.read::()?,
check_sum: s.read::()?,
offset: s.read::()?,
length: s.read::()?,
})
}
}
#[cfg(feature = "variable-fonts")]
const MAX_VAR_COORDS: usize = 64;
#[cfg(feature = "variable-fonts")]
#[derive(Clone)]
struct VarCoords {
data: [NormalizedCoordinate; MAX_VAR_COORDS],
len: u8,
}
#[cfg(feature = "variable-fonts")]
impl Default for VarCoords {
fn default() -> Self {
Self {
data: [NormalizedCoordinate::default(); MAX_VAR_COORDS],
len: u8::default(),
}
}
}
#[cfg(feature = "variable-fonts")]
impl VarCoords {
#[inline]
fn as_slice(&self) -> &[NormalizedCoordinate] {
&self.data[0..usize::from(self.len)]
}
#[inline]
fn as_mut_slice(&mut self) -> &mut [NormalizedCoordinate] {
let end = usize::from(self.len);
&mut self.data[0..end]
}
}
/// A list of font face parsing errors.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum FaceParsingError {
/// An attempt to read out of bounds detected.
///
/// Should occur only on malformed fonts.
MalformedFont,
/// Face data must start with `0x00010000`, `0x74727565`, `0x4F54544F` or `0x74746366`.
UnknownMagic,
/// The face index is larger than the number of faces in the font.
FaceIndexOutOfBounds,
/// The `head` table is missing or malformed.
NoHeadTable,
/// The `hhea` table is missing or malformed.
NoHheaTable,
/// The `maxp` table is missing or malformed.
NoMaxpTable,
}
impl core::fmt::Display for FaceParsingError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
FaceParsingError::MalformedFont => write!(f, "malformed font"),
FaceParsingError::UnknownMagic => write!(f, "unknown magic"),
FaceParsingError::FaceIndexOutOfBounds => write!(f, "face index is out of bounds"),
FaceParsingError::NoHeadTable => write!(f, "the head table is missing or malformed"),
FaceParsingError::NoHheaTable => write!(f, "the hhea table is missing or malformed"),
FaceParsingError::NoMaxpTable => write!(f, "the maxp table is missing or malformed"),
}
}
}
#[cfg(feature = "std")]
impl std::error::Error for FaceParsingError {}
/// A raw font face.
///
/// You are probably looking for [`Face`]. This is a low-level type.
///
/// Unlike [`Face`], [`RawFace`] parses only face table records.
/// Meaning all you can get from this type is a raw (`&[u8]`) data of a requested table.
/// Then you can either parse just a singe table from a font/face or populate [`RawFaceTables`]
/// manually before passing it to [`Face::from_raw_tables`].
#[derive(Clone, Copy)]
pub struct RawFace<'a> {
/// The input font file data.
pub data: &'a [u8],
/// An array of table records.
pub table_records: LazyArray16<'a, TableRecord>,
}
impl<'a> RawFace<'a> {
/// Creates a new [`RawFace`] from a raw data.
///
/// `index` indicates the specific font face in a font collection.
/// Use [`fonts_in_collection`] to get the total number of font faces.
/// Set to 0 if unsure.
///
/// While we do reuse [`FaceParsingError`], `No*Table` errors will not be throws.
#[deprecated(since = "0.16.0", note = "use `parse` instead")]
pub fn from_slice(data: &'a [u8], index: u32) -> Result {
Self::parse(data, index)
}
/// Creates a new [`RawFace`] from a raw data.
///
/// `index` indicates the specific font face in a font collection.
/// Use [`fonts_in_collection`] to get the total number of font faces.
/// Set to 0 if unsure.
///
/// While we do reuse [`FaceParsingError`], `No*Table` errors will not be throws.
pub fn parse(data: &'a [u8], index: u32) -> Result {
// https://docs.microsoft.com/en-us/typography/opentype/spec/otff#organization-of-an-opentype-font
let mut s = Stream::new(data);
// Read **font** magic.
let magic = s.read::().ok_or(FaceParsingError::UnknownMagic)?;
if magic == Magic::FontCollection {
s.skip::(); // version
let number_of_faces = s.read::().ok_or(FaceParsingError::MalformedFont)?;
let offsets = s
.read_array32::(number_of_faces)
.ok_or(FaceParsingError::MalformedFont)?;
let face_offset = offsets
.get(index)
.ok_or(FaceParsingError::FaceIndexOutOfBounds)?;
// Face offset is from the start of the font data,
// so we have to adjust it to the current parser offset.
let face_offset = face_offset
.to_usize()
.checked_sub(s.offset())
.ok_or(FaceParsingError::MalformedFont)?;
s.advance_checked(face_offset)
.ok_or(FaceParsingError::MalformedFont)?;
// Read **face** magic.
// Each face in a font collection also starts with a magic.
let magic = s.read::().ok_or(FaceParsingError::UnknownMagic)?;
// And face in a font collection can't be another collection.
if magic == Magic::FontCollection {
return Err(FaceParsingError::UnknownMagic);
}
} else {
// When reading from a regular font (not a collection) disallow index to be non-zero
// Basically treat the font as a one-element collection
if index != 0 {
return Err(FaceParsingError::FaceIndexOutOfBounds);
}
}
let num_tables = s.read::().ok_or(FaceParsingError::MalformedFont)?;
s.advance(6); // searchRange (u16) + entrySelector (u16) + rangeShift (u16)
let table_records = s
.read_array16::(num_tables)
.ok_or(FaceParsingError::MalformedFont)?;
Ok(RawFace {
data,
table_records,
})
}
/// Returns the raw data of a selected table.
pub fn table(&self, tag: Tag) -> Option<&'a [u8]> {
let (_, table) = self
.table_records
.binary_search_by(|record| record.tag.cmp(&tag))?;
let offset = usize::num_from(table.offset);
let length = usize::num_from(table.length);
let end = offset.checked_add(length)?;
self.data.get(offset..end)
}
}
impl core::fmt::Debug for RawFace<'_> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "RawFace {{ ... }}")
}
}
/// A list of all supported tables as raw data.
///
/// This type should be used in tandem with
/// [`Face::from_raw_tables()`](struct.Face.html#method.from_raw_tables).
///
/// This allows loading font faces not only from TrueType font files,
/// but from any source. Mainly used for parsing WOFF.
#[allow(missing_docs)]
#[allow(missing_debug_implementations)]
#[derive(Clone, Default)]
pub struct RawFaceTables<'a> {
// Mandatory tables.
pub head: &'a [u8],
pub hhea: &'a [u8],
pub maxp: &'a [u8],
pub bdat: Option<&'a [u8]>,
pub bloc: Option<&'a [u8]>,
pub cbdt: Option<&'a [u8]>,
pub cblc: Option<&'a [u8]>,
pub cff: Option<&'a [u8]>,
pub cmap: Option<&'a [u8]>,
pub colr: Option<&'a [u8]>,
pub cpal: Option<&'a [u8]>,
pub ebdt: Option<&'a [u8]>,
pub eblc: Option<&'a [u8]>,
pub glyf: Option<&'a [u8]>,
pub hmtx: Option<&'a [u8]>,
pub kern: Option<&'a [u8]>,
pub loca: Option<&'a [u8]>,
pub name: Option<&'a [u8]>,
pub os2: Option<&'a [u8]>,
pub post: Option<&'a [u8]>,
pub sbix: Option<&'a [u8]>,
pub svg: Option<&'a [u8]>,
pub vhea: Option<&'a [u8]>,
pub vmtx: Option<&'a [u8]>,
pub vorg: Option<&'a [u8]>,
#[cfg(feature = "opentype-layout")]
pub gdef: Option<&'a [u8]>,
#[cfg(feature = "opentype-layout")]
pub gpos: Option<&'a [u8]>,
#[cfg(feature = "opentype-layout")]
pub gsub: Option<&'a [u8]>,
#[cfg(feature = "opentype-layout")]
pub math: Option<&'a [u8]>,
#[cfg(feature = "apple-layout")]
pub ankr: Option<&'a [u8]>,
#[cfg(feature = "apple-layout")]
pub feat: Option<&'a [u8]>,
#[cfg(feature = "apple-layout")]
pub kerx: Option<&'a [u8]>,
#[cfg(feature = "apple-layout")]
pub morx: Option<&'a [u8]>,
#[cfg(feature = "apple-layout")]
pub trak: Option<&'a [u8]>,
#[cfg(feature = "variable-fonts")]
pub avar: Option<&'a [u8]>,
#[cfg(feature = "variable-fonts")]
pub cff2: Option<&'a [u8]>,
#[cfg(feature = "variable-fonts")]
pub fvar: Option<&'a [u8]>,
#[cfg(feature = "variable-fonts")]
pub gvar: Option<&'a [u8]>,
#[cfg(feature = "variable-fonts")]
pub hvar: Option<&'a [u8]>,
#[cfg(feature = "variable-fonts")]
pub mvar: Option<&'a [u8]>,
#[cfg(feature = "variable-fonts")]
pub vvar: Option<&'a [u8]>,
}
/// Parsed face tables.
///
/// Unlike [`Face`], provides a low-level parsing abstraction over TrueType tables.
/// Useful when you need a direct access to tables data.
///
/// Also, used when high-level API is problematic to implement.
/// A good example would be OpenType layout tables (GPOS/GSUB).
#[allow(missing_docs)]
#[allow(missing_debug_implementations)]
#[derive(Clone)]
pub struct FaceTables<'a> {
// Mandatory tables.
pub head: head::Table,
pub hhea: hhea::Table,
pub maxp: maxp::Table,
pub bdat: Option>,
pub cbdt: Option>,
pub cff: Option>,
pub cmap: Option>,
pub colr: Option>,
pub ebdt: Option>,
pub glyf: Option>,
pub hmtx: Option>,
pub kern: Option>,
pub name: Option>,
pub os2: Option>,
pub post: Option>,
pub sbix: Option>,
pub svg: Option>,
pub vhea: Option,
pub vmtx: Option>,
pub vorg: Option>,
#[cfg(feature = "opentype-layout")]
pub gdef: Option>,
#[cfg(feature = "opentype-layout")]
pub gpos: Option>,
#[cfg(feature = "opentype-layout")]
pub gsub: Option>,
#[cfg(feature = "opentype-layout")]
pub math: Option>,
#[cfg(feature = "apple-layout")]
pub ankr: Option>,
#[cfg(feature = "apple-layout")]
pub feat: Option>,
#[cfg(feature = "apple-layout")]
pub kerx: Option>,
#[cfg(feature = "apple-layout")]
pub morx: Option>,
#[cfg(feature = "apple-layout")]
pub trak: Option>,
#[cfg(feature = "variable-fonts")]
pub avar: Option>,
#[cfg(feature = "variable-fonts")]
pub cff2: Option>,
#[cfg(feature = "variable-fonts")]
pub fvar: Option>,
#[cfg(feature = "variable-fonts")]
pub gvar: Option>,
#[cfg(feature = "variable-fonts")]
pub hvar: Option>,
#[cfg(feature = "variable-fonts")]
pub mvar: Option>,
#[cfg(feature = "variable-fonts")]
pub vvar: Option>,
}
/// A font face.
///
/// Provides a high-level API for working with TrueType fonts.
/// If you're not familiar with how TrueType works internally, you should use this type.
/// If you do know and want a bit more low-level access - checkout [`FaceTables`].
///
/// Note that `Face` doesn't own the font data and doesn't allocate anything in heap.
/// Therefore you cannot "store" it. The idea is that you should parse the `Face`
/// when needed, get required data and forget about it.
/// That's why the initial parsing is highly optimized and should not become a bottleneck.
///
/// If you still want to store `Face` - checkout
/// [owned_ttf_parser](https://crates.io/crates/owned_ttf_parser). Requires `unsafe`.
///
/// While `Face` is technically copyable, we disallow it because it's almost 2KB big.
#[derive(Clone)]
pub struct Face<'a> {
raw_face: RawFace<'a>,
tables: FaceTables<'a>, // Parsed tables.
#[cfg(feature = "variable-fonts")]
coordinates: VarCoords,
}
impl<'a> Face<'a> {
/// Creates a new [`Face`] from a raw data.
///
/// `index` indicates the specific font face in a font collection.
/// Use [`fonts_in_collection`] to get the total number of font faces.
/// Set to 0 if unsure.
///
/// This method will do some parsing and sanitization,
/// but in general can be considered free. No significant performance overhead.
///
/// Required tables: `head`, `hhea` and `maxp`.
///
/// If an optional table has invalid data it will be skipped.
#[deprecated(since = "0.16.0", note = "use `parse` instead")]
pub fn from_slice(data: &'a [u8], index: u32) -> Result {
Self::parse(data, index)
}
/// Creates a new [`Face`] from a raw data.
///
/// `index` indicates the specific font face in a font collection.
/// Use [`fonts_in_collection`] to get the total number of font faces.
/// Set to 0 if unsure.
///
/// This method will do some parsing and sanitization,
/// but in general can be considered free. No significant performance overhead.
///
/// Required tables: `head`, `hhea` and `maxp`.
///
/// If an optional table has invalid data it will be skipped.
pub fn parse(data: &'a [u8], index: u32) -> Result {
let raw_face = RawFace::parse(data, index)?;
let raw_tables = Self::collect_tables(raw_face);
#[allow(unused_mut)]
let mut face = Face {
raw_face,
#[cfg(feature = "variable-fonts")]
coordinates: VarCoords::default(),
tables: Self::parse_tables(raw_tables)?,
};
#[cfg(feature = "variable-fonts")]
{
if let Some(ref fvar) = face.tables.fvar {
face.coordinates.len = fvar.axes.len().min(MAX_VAR_COORDS as u16) as u8;
}
}
Ok(face)
}
fn collect_tables(raw_face: RawFace<'a>) -> RawFaceTables<'a> {
let mut tables = RawFaceTables::default();
for record in raw_face.table_records {
let start = usize::num_from(record.offset);
let end = match start.checked_add(usize::num_from(record.length)) {
Some(v) => v,
None => continue,
};
let table_data = raw_face.data.get(start..end);
match &record.tag.to_bytes() {
b"bdat" => tables.bdat = table_data,
b"bloc" => tables.bloc = table_data,
b"CBDT" => tables.cbdt = table_data,
b"CBLC" => tables.cblc = table_data,
b"CFF " => tables.cff = table_data,
#[cfg(feature = "variable-fonts")]
b"CFF2" => tables.cff2 = table_data,
b"COLR" => tables.colr = table_data,
b"CPAL" => tables.cpal = table_data,
b"EBDT" => tables.ebdt = table_data,
b"EBLC" => tables.eblc = table_data,
#[cfg(feature = "opentype-layout")]
b"GDEF" => tables.gdef = table_data,
#[cfg(feature = "opentype-layout")]
b"GPOS" => tables.gpos = table_data,
#[cfg(feature = "opentype-layout")]
b"GSUB" => tables.gsub = table_data,
#[cfg(feature = "opentype-layout")]
b"MATH" => tables.math = table_data,
#[cfg(feature = "variable-fonts")]
b"HVAR" => tables.hvar = table_data,
#[cfg(feature = "variable-fonts")]
b"MVAR" => tables.mvar = table_data,
b"OS/2" => tables.os2 = table_data,
b"SVG " => tables.svg = table_data,
b"VORG" => tables.vorg = table_data,
#[cfg(feature = "variable-fonts")]
b"VVAR" => tables.vvar = table_data,
#[cfg(feature = "apple-layout")]
b"ankr" => tables.ankr = table_data,
#[cfg(feature = "variable-fonts")]
b"avar" => tables.avar = table_data,
b"cmap" => tables.cmap = table_data,
#[cfg(feature = "apple-layout")]
b"feat" => tables.feat = table_data,
#[cfg(feature = "variable-fonts")]
b"fvar" => tables.fvar = table_data,
b"glyf" => tables.glyf = table_data,
#[cfg(feature = "variable-fonts")]
b"gvar" => tables.gvar = table_data,
b"head" => tables.head = table_data.unwrap_or_default(),
b"hhea" => tables.hhea = table_data.unwrap_or_default(),
b"hmtx" => tables.hmtx = table_data,
b"kern" => tables.kern = table_data,
#[cfg(feature = "apple-layout")]
b"kerx" => tables.kerx = table_data,
b"loca" => tables.loca = table_data,
b"maxp" => tables.maxp = table_data.unwrap_or_default(),
#[cfg(feature = "apple-layout")]
b"morx" => tables.morx = table_data,
b"name" => tables.name = table_data,
b"post" => tables.post = table_data,
b"sbix" => tables.sbix = table_data,
#[cfg(feature = "apple-layout")]
b"trak" => tables.trak = table_data,
b"vhea" => tables.vhea = table_data,
b"vmtx" => tables.vmtx = table_data,
_ => {}
}
}
tables
}
/// Creates a new [`Face`] from provided [`RawFaceTables`].
pub fn from_raw_tables(raw_tables: RawFaceTables<'a>) -> Result {
#[allow(unused_mut)]
let mut face = Face {
raw_face: RawFace {
data: &[],
table_records: LazyArray16::default(),
},
#[cfg(feature = "variable-fonts")]
coordinates: VarCoords::default(),
tables: Self::parse_tables(raw_tables)?,
};
#[cfg(feature = "variable-fonts")]
{
if let Some(ref fvar) = face.tables.fvar {
face.coordinates.len = fvar.axes.len().min(MAX_VAR_COORDS as u16) as u8;
}
}
Ok(face)
}
fn parse_tables(raw_tables: RawFaceTables<'a>) -> Result, FaceParsingError> {
let head = head::Table::parse(raw_tables.head).ok_or(FaceParsingError::NoHeadTable)?;
let hhea = hhea::Table::parse(raw_tables.hhea).ok_or(FaceParsingError::NoHheaTable)?;
let maxp = maxp::Table::parse(raw_tables.maxp).ok_or(FaceParsingError::NoMaxpTable)?;
let hmtx = raw_tables.hmtx.and_then(|data| {
hmtx::Table::parse(hhea.number_of_metrics, maxp.number_of_glyphs, data)
});
let vhea = raw_tables.vhea.and_then(vhea::Table::parse);
let vmtx = if let Some(vhea) = vhea {
raw_tables.vmtx.and_then(|data| {
hmtx::Table::parse(vhea.number_of_metrics, maxp.number_of_glyphs, data)
})
} else {
None
};
let loca = raw_tables.loca.and_then(|data| {
loca::Table::parse(maxp.number_of_glyphs, head.index_to_location_format, data)
});
let glyf = if let Some(loca) = loca {
raw_tables
.glyf
.and_then(|data| glyf::Table::parse(loca, data))
} else {
None
};
let bdat = if let Some(bloc) = raw_tables.bloc.and_then(cblc::Table::parse) {
raw_tables
.bdat
.and_then(|data| cbdt::Table::parse(bloc, data))
} else {
None
};
let cbdt = if let Some(cblc) = raw_tables.cblc.and_then(cblc::Table::parse) {
raw_tables
.cbdt
.and_then(|data| cbdt::Table::parse(cblc, data))
} else {
None
};
let ebdt = if let Some(eblc) = raw_tables.eblc.and_then(cblc::Table::parse) {
raw_tables
.ebdt
.and_then(|data| cbdt::Table::parse(eblc, data))
} else {
None
};
let cpal = raw_tables.cpal.and_then(cpal::Table::parse);
let colr = if let Some(cpal) = cpal {
raw_tables
.colr
.and_then(|data| colr::Table::parse(cpal, data))
} else {
None
};
Ok(FaceTables {
head,
hhea,
maxp,
bdat,
cbdt,
cff: raw_tables.cff.and_then(cff::Table::parse),
cmap: raw_tables.cmap.and_then(cmap::Table::parse),
colr,
ebdt,
glyf,
hmtx,
kern: raw_tables.kern.and_then(kern::Table::parse),
name: raw_tables.name.and_then(name::Table::parse),
os2: raw_tables.os2.and_then(os2::Table::parse),
post: raw_tables.post.and_then(post::Table::parse),
sbix: raw_tables
.sbix
.and_then(|data| sbix::Table::parse(maxp.number_of_glyphs, data)),
svg: raw_tables.svg.and_then(svg::Table::parse),
vhea: raw_tables.vhea.and_then(vhea::Table::parse),
vmtx,
vorg: raw_tables.vorg.and_then(vorg::Table::parse),
#[cfg(feature = "opentype-layout")]
gdef: raw_tables.gdef.and_then(gdef::Table::parse),
#[cfg(feature = "opentype-layout")]
gpos: raw_tables
.gpos
.and_then(opentype_layout::LayoutTable::parse),
#[cfg(feature = "opentype-layout")]
gsub: raw_tables
.gsub
.and_then(opentype_layout::LayoutTable::parse),
#[cfg(feature = "opentype-layout")]
math: raw_tables.math.and_then(math::Table::parse),
#[cfg(feature = "apple-layout")]
ankr: raw_tables
.ankr
.and_then(|data| ankr::Table::parse(maxp.number_of_glyphs, data)),
#[cfg(feature = "apple-layout")]
feat: raw_tables.feat.and_then(feat::Table::parse),
#[cfg(feature = "apple-layout")]
kerx: raw_tables
.kerx
.and_then(|data| kerx::Table::parse(maxp.number_of_glyphs, data)),
#[cfg(feature = "apple-layout")]
morx: raw_tables
.morx
.and_then(|data| morx::Table::parse(maxp.number_of_glyphs, data)),
#[cfg(feature = "apple-layout")]
trak: raw_tables.trak.and_then(trak::Table::parse),
#[cfg(feature = "variable-fonts")]
avar: raw_tables.avar.and_then(avar::Table::parse),
#[cfg(feature = "variable-fonts")]
cff2: raw_tables.cff2.and_then(cff2::Table::parse),
#[cfg(feature = "variable-fonts")]
fvar: raw_tables.fvar.and_then(fvar::Table::parse),
#[cfg(feature = "variable-fonts")]
gvar: raw_tables.gvar.and_then(gvar::Table::parse),
#[cfg(feature = "variable-fonts")]
hvar: raw_tables.hvar.and_then(hvar::Table::parse),
#[cfg(feature = "variable-fonts")]
mvar: raw_tables.mvar.and_then(mvar::Table::parse),
#[cfg(feature = "variable-fonts")]
vvar: raw_tables.vvar.and_then(vvar::Table::parse),
})
}
/// Returns low-level face tables.
#[inline]
pub fn tables(&self) -> &FaceTables<'a> {
&self.tables
}
/// Returns the `RawFace` used to create this `Face`.
///
/// Useful if you want to parse the data manually.
///
/// Available only for faces created using [`Face::parse()`](struct.Face.html#method.parse).
#[inline]
pub fn raw_face(&self) -> &RawFace<'a> {
&self.raw_face
}
/// Returns the raw data of a selected table.
///
/// Useful if you want to parse the data manually.
///
/// Available only for faces created using [`Face::parse()`](struct.Face.html#method.parse).
#[deprecated(since = "0.16.0", note = "use `self.raw_face().table()` instead")]
#[inline]
pub fn table_data(&self, tag: Tag) -> Option<&'a [u8]> {
self.raw_face.table(tag)
}
/// Returns a list of names.
///
/// Contains face name and other strings.
#[inline]
pub fn names(&self) -> name::Names<'a> {
self.tables.name.unwrap_or_default().names
}
/// Checks that face is marked as *Regular*.
///
/// Returns `false` when OS/2 table is not present.
#[inline]
pub fn is_regular(&self) -> bool {
self.tables
.os2
.map(|s| s.style() == Style::Normal)
.unwrap_or(false)
}
/// Checks that face is marked as *Italic*.
///
/// Returns `false` when OS/2 table is not present.
#[inline]
pub fn is_italic(&self) -> bool {
self.tables
.os2
.map(|s| s.style() == Style::Italic)
.unwrap_or(false)
}
/// Checks that face is marked as *Bold*.
///
/// Returns `false` when OS/2 table is not present.
#[inline]
pub fn is_bold(&self) -> bool {
self.tables.os2.map(|os2| os2.is_bold()).unwrap_or(false)
}
/// Checks that face is marked as *Oblique*.
///
/// Returns `false` when OS/2 table is not present or when its version is < 4.
#[inline]
pub fn is_oblique(&self) -> bool {
self.tables
.os2
.map(|s| s.style() == Style::Oblique)
.unwrap_or(false)
}
/// Returns face style.
#[inline]
pub fn style(&self) -> Style {
self.tables.os2.map(|os2| os2.style()).unwrap_or_default()
}
/// Checks that face is marked as *Monospaced*.
///
/// Returns `false` when `post` table is not present.
#[inline]
pub fn is_monospaced(&self) -> bool {
self.tables
.post
.map(|post| post.is_monospaced)
.unwrap_or(false)
}
/// Checks that face is variable.
///
/// Simply checks the presence of a `fvar` table.
#[inline]
pub fn is_variable(&self) -> bool {
#[cfg(feature = "variable-fonts")]
{
// `fvar::Table::parse` already checked that `axisCount` is non-zero.
self.tables.fvar.is_some()
}
#[cfg(not(feature = "variable-fonts"))]
{
false
}
}
/// Returns face's weight.
///
/// Returns `Weight::Normal` when OS/2 table is not present.
#[inline]
pub fn weight(&self) -> Weight {
self.tables.os2.map(|os2| os2.weight()).unwrap_or_default()
}
/// Returns face's width.
///
/// Returns `Width::Normal` when OS/2 table is not present or when value is invalid.
#[inline]
pub fn width(&self) -> Width {
self.tables.os2.map(|os2| os2.width()).unwrap_or_default()
}
/// Returns face's italic angle.
///
/// Returns `None` when `post` table is not present.
#[inline]
pub fn italic_angle(&self) -> Option {
self.tables.post.map(|table| table.italic_angle)
}
// Read https://github.com/freetype/freetype/blob/49270c17011491227ec7bd3fb73ede4f674aa065/src/sfnt/sfobjs.c#L1279
// to learn more about the logic behind the following functions.
/// Returns a horizontal face ascender.
///
/// This method is affected by variation axes.
#[inline]
pub fn ascender(&self) -> i16 {
if let Some(os_2) = self.tables.os2 {
if os_2.use_typographic_metrics() {
let value = os_2.typographic_ascender();
return self.apply_metrics_variation(Tag::from_bytes(b"hasc"), value);
}
}
let mut value = self.tables.hhea.ascender;
if value == 0 {
if let Some(os_2) = self.tables.os2 {
value = os_2.typographic_ascender();
if value == 0 {
value = os_2.windows_ascender();
value = self.apply_metrics_variation(Tag::from_bytes(b"hcla"), value);
} else {
value = self.apply_metrics_variation(Tag::from_bytes(b"hasc"), value);
}
}
}
value
}
/// Returns a horizontal face descender.
///
/// This method is affected by variation axes.
#[inline]
pub fn descender(&self) -> i16 {
if let Some(os_2) = self.tables.os2 {
if os_2.use_typographic_metrics() {
let value = os_2.typographic_descender();
return self.apply_metrics_variation(Tag::from_bytes(b"hdsc"), value);
}
}
let mut value = self.tables.hhea.descender;
if value == 0 {
if let Some(os_2) = self.tables.os2 {
value = os_2.typographic_descender();
if value == 0 {
value = os_2.windows_descender();
value = self.apply_metrics_variation(Tag::from_bytes(b"hcld"), value);
} else {
value = self.apply_metrics_variation(Tag::from_bytes(b"hdsc"), value);
}
}
}
value
}
/// Returns face's height.
///
/// This method is affected by variation axes.
#[inline]
pub fn height(&self) -> i16 {
self.ascender() - self.descender()
}
/// Returns a horizontal face line gap.
///
/// This method is affected by variation axes.
#[inline]
pub fn line_gap(&self) -> i16 {
if let Some(os_2) = self.tables.os2 {
if os_2.use_typographic_metrics() {
let value = os_2.typographic_line_gap();
return self.apply_metrics_variation(Tag::from_bytes(b"hlgp"), value);
}
}
let mut value = self.tables.hhea.line_gap;
// For line gap, we have to check that ascender or descender are 0, not line gap itself.
if self.tables.hhea.ascender == 0 || self.tables.hhea.descender == 0 {
if let Some(os_2) = self.tables.os2 {
if os_2.typographic_ascender() != 0 || os_2.typographic_descender() != 0 {
value = os_2.typographic_line_gap();
value = self.apply_metrics_variation(Tag::from_bytes(b"hlgp"), value);
} else {
value = 0;
}
}
}
value
}
/// Returns a horizontal typographic face ascender.
///
/// Prefer `Face::ascender` unless you explicitly want this. This is a more
/// low-level alternative.
///
/// This method is affected by variation axes.
///
/// Returns `None` when OS/2 table is not present.
#[inline]
pub fn typographic_ascender(&self) -> Option {
self.tables.os2.map(|table| {
let v = table.typographic_ascender();
self.apply_metrics_variation(Tag::from_bytes(b"hasc"), v)
})
}
/// Returns a horizontal typographic face descender.
///
/// Prefer `Face::descender` unless you explicitly want this. This is a more
/// low-level alternative.
///
/// This method is affected by variation axes.
///
/// Returns `None` when OS/2 table is not present.
#[inline]
pub fn typographic_descender(&self) -> Option {
self.tables.os2.map(|table| {
let v = table.typographic_descender();
self.apply_metrics_variation(Tag::from_bytes(b"hdsc"), v)
})
}
/// Returns a horizontal typographic face line gap.
///
/// Prefer `Face::line_gap` unless you explicitly want this. This is a more
/// low-level alternative.
///
/// This method is affected by variation axes.
///
/// Returns `None` when OS/2 table is not present.
#[inline]
pub fn typographic_line_gap(&self) -> Option {
self.tables.os2.map(|table| {
let v = table.typographic_line_gap();
self.apply_metrics_variation(Tag::from_bytes(b"hlgp"), v)
})
}
/// Returns a vertical face ascender.
///
/// This method is affected by variation axes.
#[inline]
pub fn vertical_ascender(&self) -> Option {
self.tables
.vhea
.map(|vhea| vhea.ascender)
.map(|v| self.apply_metrics_variation(Tag::from_bytes(b"vasc"), v))
}
/// Returns a vertical face descender.
///
/// This method is affected by variation axes.
#[inline]
pub fn vertical_descender(&self) -> Option {
self.tables
.vhea
.map(|vhea| vhea.descender)
.map(|v| self.apply_metrics_variation(Tag::from_bytes(b"vdsc"), v))
}
/// Returns a vertical face height.
///
/// This method is affected by variation axes.
#[inline]
pub fn vertical_height(&self) -> Option {
Some(self.vertical_ascender()? - self.vertical_descender()?)
}
/// Returns a vertical face line gap.
///
/// This method is affected by variation axes.
#[inline]
pub fn vertical_line_gap(&self) -> Option {
self.tables
.vhea
.map(|vhea| vhea.line_gap)
.map(|v| self.apply_metrics_variation(Tag::from_bytes(b"vlgp"), v))
}
/// Returns face's units per EM.
///
/// Guarantee to be in a 16..=16384 range.
#[inline]
pub fn units_per_em(&self) -> u16 {
self.tables.head.units_per_em
}
/// Returns face's x height.
///
/// This method is affected by variation axes.
///
/// Returns `None` when OS/2 table is not present or when its version is < 2.
#[inline]
pub fn x_height(&self) -> Option {
self.tables
.os2
.and_then(|os_2| os_2.x_height())
.map(|v| self.apply_metrics_variation(Tag::from_bytes(b"xhgt"), v))
}
/// Returns face's capital height.
///
/// This method is affected by variation axes.
///
/// Returns `None` when OS/2 table is not present or when its version is < 2.
#[inline]
pub fn capital_height(&self) -> Option {
self.tables
.os2
.and_then(|os_2| os_2.capital_height())
.map(|v| self.apply_metrics_variation(Tag::from_bytes(b"cpht"), v))
}
/// Returns face's underline metrics.
///
/// This method is affected by variation axes.
///
/// Returns `None` when `post` table is not present.
#[inline]
pub fn underline_metrics(&self) -> Option {
let mut metrics = self.tables.post?.underline_metrics;
if self.is_variable() {
self.apply_metrics_variation_to(Tag::from_bytes(b"undo"), &mut metrics.position);
self.apply_metrics_variation_to(Tag::from_bytes(b"unds"), &mut metrics.thickness);
}
Some(metrics)
}
/// Returns face's strikeout metrics.
///
/// This method is affected by variation axes.
///
/// Returns `None` when OS/2 table is not present.
#[inline]
pub fn strikeout_metrics(&self) -> Option