Struct GlyfTable 

pub struct GlyfTable<'a> { /* private fields */ }

glyf table

https://docs.microsoft.com/en-us/typography/opentype/spec/glyf

Implementations

impl<'a> GlyfTable<'a>

pub fn subset(&self, glyph_ids: &[u16]) -> Result<SubsetGlyf<'a>, ParseError>

Returns a copy of this table that only contains the glyphs specified by glyph_ids.

impl<'a> GlyfTable<'a>

pub fn new(records: Vec<GlyfRecord<'a>>) -> Result<Self, ParseError>

pub fn num_glyphs(&self) -> u16

Returns the number of glyphs in this glyf table.

Returns a u16 for convenience of interacting with other parts of the code.

pub fn records(&self) -> &[GlyfRecord<'a>]

pub fn records_mut(&mut self) -> &mut [GlyfRecord<'a>]

pub fn push(&mut self, record: GlyfRecord<'a>) -> Result<(), ParseError>

pub fn get_parsed_glyph( &mut self, glyph_index: u16, ) -> Result<&Glyph<'a>, ParseError>

Returns a parsed glyph, converting GlyfRecord::Present into GlyfRecord::Parsed if necessary.

Trait Implementations

impl<'a> Debug for GlyfTable<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> OutlineBuilder for GlyfTable<'a>

type Error = ParseError

fn visit<V: OutlineSink>( &mut self, glyph_index: u16, visitor: &mut V, ) -> Result<(), Self::Error>

Visit the glyph outlines in self.

impl<'a> PartialEq for GlyfTable<'a>

fn eq(&self, other: &GlyfTable<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'b> ReadBinaryDep for GlyfTable<'b>

type Args<'a> = &'a LocaTable<'a>

type HostType<'a> = GlyfTable<'a>

fn read_dep<'a>( ctxt: &mut ReadCtxt<'a>, loca: Self::Args<'a>, ) -> Result<Self::HostType<'a>, ParseError>

impl<'a> WriteBinaryDep for GlyfTable<'a>

fn write_dep<C: WriteContext>( ctxt: &mut C, table: GlyfTable<'a>, index_to_loc_format: IndexToLocFormat, ) -> Result<Self::Output, WriteError>

Write this glyf table into ctxt.

A Note About Padding

On the loca table documentation at the bottom it states:

Note that the local offsets should be 32-bit aligned. Offsets which are not 32-bit aligned may seriously degrade performance of some processors.

On the Recommendations for OpenType Fonts page it states:

We recommend that local offsets should be 16-bit aligned, in both the short and long formats of this table.

On Apple’s loca documentation it says:

The glyph data is always word aligned.

Elsewhere in the Apple docs they refer to long as 32-bits, so assuming word here means 16-bits.

An issue was raised against Microsoft’s docs regarding this. Behdad Esfahbod commented:

All the requirements should be removed since 2019.

In reality, in the short format, you are forced to do 16-bit alignment because of how offsets are stored. In the long format, use alignment 1. We’ve been doing that in fonttools for years and never ever heard a complaint whatsoever.

So with this in mind we implement 16-bit alignment when index_to_loc_format is 0, and no alignment/padding otherwise.

type Output = LocaTable

The type of the value returned by write_dep.

type Args = IndexToLocFormat

The type of the arguments supplied to write_dep.

impl<'a> StructuralPartialEq for GlyfTable<'a>