pub struct Face<'a> { /* private fields */ }
Expand description

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. Requires unsafe.

While Face is technically copyable, we disallow it because it’s almost 2KB big.

Implementations

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.

Creates a new Face from provided RawFaceTables.

Returns low-level face tables.

Returns the raw data of a selected table.

Useful if you want to parse the data manually.

Available only for faces created using Face::from_slice().

Returns a list of names.

Contains face name and other strings.

Checks that face is marked as Regular.

Returns false when OS/2 table is not present.

Checks that face is marked as Italic.

Returns false when OS/2 table is not present.

Checks that face is marked as Bold.

Returns false when OS/2 table is not present.

Checks that face is marked as Oblique.

Returns false when OS/2 table is not present or when its version is < 4.

Returns face style.

Checks that face is marked as Monospaced.

Returns false when post table is not present.

Checks that face is variable.

Simply checks the presence of a fvar table.

Returns face’s weight.

Returns Weight::Normal when OS/2 table is not present.

Returns face’s width.

Returns Width::Normal when OS/2 table is not present or when value is invalid.

Returns face’s italic angle.

Returns None when post table is not present.

Returns a horizontal face ascender.

This method is affected by variation axes.

Returns a horizontal face descender.

This method is affected by variation axes.

Returns face’s height.

This method is affected by variation axes.

Returns a horizontal face line gap.

This method is affected by variation axes.

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.

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.

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.

Returns a vertical face ascender.

This method is affected by variation axes.

Returns a vertical face descender.

This method is affected by variation axes.

Returns a vertical face height.

This method is affected by variation axes.

Returns a vertical face line gap.

This method is affected by variation axes.

Returns face’s units per EM.

Guarantee to be in a 16..=16384 range.

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.

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.

Returns face’s underline metrics.

This method is affected by variation axes.

Returns None when post table is not present.

Returns face’s strikeout metrics.

This method is affected by variation axes.

Returns None when OS/2 table is not present.

Returns face’s subscript metrics.

This method is affected by variation axes.

Returns None when OS/2 table is not present.

Returns face’s superscript metrics.

This method is affected by variation axes.

Returns None when OS/2 table is not present.

Returns a total number of glyphs in the face.

Never zero.

The value was already parsed, so this function doesn’t involve any parsing.

Resolves a Glyph ID for a code point.

Returns None instead of 0 when glyph is not found.

All subtable formats except Mixed Coverage (8) are supported.

If you need a more low-level control, prefer Face::tables().cmap.

Resolves a variation of a Glyph ID from two code points.

Implemented according to Unicode Variation Sequences.

Returns None instead of 0 when glyph is not found.

Returns glyph’s horizontal advance.

This method is affected by variation axes.

Returns glyph’s vertical advance.

This method is affected by variation axes.

Returns glyph’s horizontal side bearing.

This method is affected by variation axes.

Returns glyph’s vertical side bearing.

This method is affected by variation axes.

Returns glyph’s vertical origin according to Vertical Origin Table.

Returns glyph’s name.

Uses the post and CFF tables as sources.

Returns None when no name is associated with a glyph.

Outlines a glyph and returns its tight bounding box.

Warning: since ttf-parser is a pull parser, OutlineBuilder will emit segments even when outline is partially malformed. You must check outline_glyph() result before using OutlineBuilder’s output.

gvar, glyf, CFF and CFF2 tables are supported. And they will be accesses in this specific order.

This method is affected by variation axes.

Returns None when glyph has no outline or on error.

Example
use std::fmt::Write;
use ttf_parser;

struct Builder(String);

impl ttf_parser::OutlineBuilder for Builder {
    fn move_to(&mut self, x: f32, y: f32) {
        write!(&mut self.0, "M {} {} ", x, y).unwrap();
    }

    fn line_to(&mut self, x: f32, y: f32) {
        write!(&mut self.0, "L {} {} ", x, y).unwrap();
    }

    fn quad_to(&mut self, x1: f32, y1: f32, x: f32, y: f32) {
        write!(&mut self.0, "Q {} {} {} {} ", x1, y1, x, y).unwrap();
    }

    fn curve_to(&mut self, x1: f32, y1: f32, x2: f32, y2: f32, x: f32, y: f32) {
        write!(&mut self.0, "C {} {} {} {} {} {} ", x1, y1, x2, y2, x, y).unwrap();
    }

    fn close(&mut self) {
        write!(&mut self.0, "Z ").unwrap();
    }
}

let data = std::fs::read("tests/fonts/demo.ttf").unwrap();
let face = ttf_parser::Face::from_slice(&data, 0).unwrap();
let mut builder = Builder(String::new());
let bbox = face.outline_glyph(ttf_parser::GlyphId(1), &mut builder).unwrap();
assert_eq!(builder.0, "M 173 267 L 369 267 L 270 587 L 173 267 Z M 6 0 L 224 656 \
                       L 320 656 L 541 0 L 452 0 L 390 200 L 151 200 L 85 0 L 6 0 Z ");
assert_eq!(bbox, ttf_parser::Rect { x_min: 6, y_min: 0, x_max: 541, y_max: 656 });

Returns a tight glyph bounding box.

This is just a shorthand for outline_glyph() since only the glyf table stores a bounding box. We ignore glyf table bboxes because they can be malformed. In case of CFF and variable fonts we have to actually outline a glyph to find it’s bounding box.

When a glyph is defined by a raster or a vector image, that can be obtained via glyph_image(), the bounding box must be calculated manually and this method will return None.

Note: the returned bbox is not validated in any way. A font file can have a glyph bbox set to zero/negative width and/or height and this is perfectly ok. For calculated bboxes, zero width and/or height is also perfectly fine.

This method is affected by variation axes.

Returns a bounding box that large enough to enclose any glyph from the face.

Returns a reference to a glyph’s raster image.

A font can define a glyph using a raster or a vector image instead of a simple outline. Which is primarily used for emojis. This method should be used to access raster images.

pixels_per_em allows selecting a preferred image size. The chosen size will be closer to an upper one. So when font has 64px and 96px images and pixels_per_em is set to 72, 96px image will be returned. To get the largest image simply use std::u16::MAX.

Note that this method will return an encoded image. It should be decoded by the caller. We don’t validate or preprocess it in any way.

Currently, only PNG images are supported.

Also, a font can contain both: images and outlines. So when this method returns None you should also try outline_glyph() afterwards.

There are multiple ways an image can be stored in a TrueType font and this method supports only sbix, CBLC+CBDT. Font’s tables be accesses in this specific order.

Returns a reference to a glyph’s SVG image.

A font can define a glyph using a raster or a vector image instead of a simple outline. Which is primarily used for emojis. This method should be used to access SVG images.

Note that this method will return just an SVG data. It should be rendered or even decompressed (in case of SVGZ) by the caller. We don’t validate or preprocess it in any way.

Also, a font can contain both: images and outlines. So when this method returns None you should also try outline_glyph() afterwards.

Returns an iterator over variation axes.

Sets a variation axis coordinate.

This is the only mutable method in the library. We can simplify the API a lot by storing the variable coordinates in the face object itself.

Since coordinates are stored on the stack, we allow only 32 of them.

Returns None when face is not variable or doesn’t have such axis.

Returns the current normalized variation coordinates.

Checks that face has non-default variation coordinates.

Trait Implementations

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

Uses borrowed data to replace owned data, usually by cloning. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.