Struct Table 

pub struct Table<'a> {
    pub encoding: Encoding<'a>,
    pub charset: Charset<'a>,
    /* private fields */
}

A Compact Font Format Table.

Fields

encoding: Encoding<'a>

charset: Charset<'a>

Implementations

impl<'a> Table<'a>

pub fn parse(data: &'a [u8]) -> Option<Self>

Parses a table from raw data.

Examples found in repository

examples/tounicode.rs (line 14)

fn main() {
    // open the file passed on the comanmand line
    let path = std::env::args().nth(1).expect("no file given");
    let file = std::fs::File::open(&path).expect("could not open file");
    let mut reader = std::io::BufReader::new(file);
    let mut buffer = Vec::new();
    reader
        .read_to_end(&mut buffer)
        .expect("could not read file");
    let table = Table::parse(&buffer).unwrap();

    let encoding = table.encoding.get_code_to_sid_table(&table.charset);
    for (cid, sid) in encoding.iter() {
        println!("{}: {:?}", cid, string_by_id(&table, *sid));
    }
}

examples/dump.rs (line 15)

fn main() {
    // open the file passed on the comanmand line
    let path = std::env::args().nth(1).expect("no file given");
    let file = std::fs::File::open(&path).expect("could not open file");
    let mut reader = std::io::BufReader::new(file);
    let mut buffer = Vec::new();
    reader
        .read_to_end(&mut buffer)
        .expect("could not read file");
    let table = Table::parse(&buffer).unwrap();
    dbg!(&table);
    println!("full name: {:?}", table.full_name());
    println!("family name: {:?}", table.family_name());
    println!("version: {:?}", table.version());
    println!("notice: {:?}", table.notice());
    println!("number of glyphs: {:?}", table.number_of_glyphs());

    println!("charset:");
    match table.charset {
        Charset::ISOAdobe => println!("ISOAdobe"),
        Charset::Expert => println!("Expert"),
        Charset::ExpertSubset => println!("ExpertSubset"),
        Charset::Format0(ref array) => {
            println!("Format0:");
            for sid in *array {
                println!("  {:?}", string_by_id(&table, sid));
            }
        }
        Charset::Format1(ref array) => {
            println!("Format1:");
            for range in *array {
                let sid = range.first;
                let count = range.left;
                println!("  {:?} {:?}", sid, count);
                for i in 0..=count {
                    println!(
                        "    {:?}",
                        string_by_id(&table, StringId(sid.0 + u16::from(i)))
                    );
                }
            }
        }
        Charset::Format2(ref array) => {
            println!("Format2:");
            for range in *array {
                let sid = range.first;
                let count = range.left;
                println!("  {:?} {:?}", sid, count);
                for i in 0..=count {
                    println!("    {:?}", string_by_id(&table, StringId(sid.0 + i)));
                }
            }
        }
    }
    println!("encoding:");
    match table.encoding.kind {
        cff_parser::EncodingKind::Standard => println!("Standard"),
        cff_parser::EncodingKind::Expert => println!("Expert"),
        cff_parser::EncodingKind::Format0(ref array) => {
            println!("Format0:");
            for code in *array {
                println!("  {:?}", code);
            }
        }
        cff_parser::EncodingKind::Format1(ref array) => {
            println!("Format1:");
            for range in *array {
                println!("  {:?} {:?}", range.first, range.left);
            }
        }
    }
}

pub fn number_of_glyphs(&self) -> u16

Returns a total number of glyphs in the font.

Never zero.

Examples found in repository

examples/dump.rs (line 21)

fn main() {
    // open the file passed on the comanmand line
    let path = std::env::args().nth(1).expect("no file given");
    let file = std::fs::File::open(&path).expect("could not open file");
    let mut reader = std::io::BufReader::new(file);
    let mut buffer = Vec::new();
    reader
        .read_to_end(&mut buffer)
        .expect("could not read file");
    let table = Table::parse(&buffer).unwrap();
    dbg!(&table);
    println!("full name: {:?}", table.full_name());
    println!("family name: {:?}", table.family_name());
    println!("version: {:?}", table.version());
    println!("notice: {:?}", table.notice());
    println!("number of glyphs: {:?}", table.number_of_glyphs());

    println!("charset:");
    match table.charset {
        Charset::ISOAdobe => println!("ISOAdobe"),
        Charset::Expert => println!("Expert"),
        Charset::ExpertSubset => println!("ExpertSubset"),
        Charset::Format0(ref array) => {
            println!("Format0:");
            for sid in *array {
                println!("  {:?}", string_by_id(&table, sid));
            }
        }
        Charset::Format1(ref array) => {
            println!("Format1:");
            for range in *array {
                let sid = range.first;
                let count = range.left;
                println!("  {:?} {:?}", sid, count);
                for i in 0..=count {
                    println!(
                        "    {:?}",
                        string_by_id(&table, StringId(sid.0 + u16::from(i)))
                    );
                }
            }
        }
        Charset::Format2(ref array) => {
            println!("Format2:");
            for range in *array {
                let sid = range.first;
                let count = range.left;
                println!("  {:?} {:?}", sid, count);
                for i in 0..=count {
                    println!("    {:?}", string_by_id(&table, StringId(sid.0 + i)));
                }
            }
        }
    }
    println!("encoding:");
    match table.encoding.kind {
        cff_parser::EncodingKind::Standard => println!("Standard"),
        cff_parser::EncodingKind::Expert => println!("Expert"),
        cff_parser::EncodingKind::Format0(ref array) => {
            println!("Format0:");
            for code in *array {
                println!("  {:?}", code);
            }
        }
        cff_parser::EncodingKind::Format1(ref array) => {
            println!("Format1:");
            for range in *array {
                println!("  {:?} {:?}", range.first, range.left);
            }
        }
    }
}

pub fn matrix(&self) -> Matrix

Returns a font transformation matrix.

pub fn glyph_fd_matrix(&self, glyph_id: GlyphId) -> Matrix

Returns the FontMatrix for the FD that owns glyph_id.

CID-keyed CFF fonts can define a per-FD FontMatrix in each entry of the FDArray (op 12 7). If the FD has one it overrides the top-level matrix. For SID fonts (no FDArray) or when the FD has no explicit matrix, falls back to the top-level matrix.

Use this instead of matrix() when converting CFF charstring advances to PDF text-space widths for CIDFontType0 width repair (6.2.11.5:1).

pub fn outline( &self, glyph_id: GlyphId, builder: &mut dyn OutlineBuilder, ) -> Result<Rect, CFFError>

Outlines a glyph.

pub fn glyph_index(&self, code_point: u8) -> Option<GlyphId>

Resolves a Glyph ID for a code point.

Similar to Face::glyph_index but 8bit and uses CFF encoding and charset tables instead of TrueType cmap.

pub fn glyph_width(&self, glyph_id: GlyphId) -> Option<u16>

Returns a glyph width.

This value is different from outline bbox width and is stored separately.

Technically similar to Face::glyph_hor_advance.

pub fn glyph_width_f64(&self, glyph_id: GlyphId) -> Option<f64>

Returns the glyph width as a signed f64 value.

Unlike [glyph_width] which returns u16 (and None for negative widths), this preserves the full CFF charstring advance including negative values that can arise from nominalWidthX offsets.

pub fn glyph_width_f32(&self, glyph_id: GlyphId) -> Option<f32>

Returns the glyph width as a signed f32 value.

Prefer [glyph_width_f64] when exact PDF width reconstruction matters.

pub fn glyph_width_f64_verapdf(&self, glyph_id: GlyphId) -> Option<f64>

The advance as veraPDF 1.28.2 computes it for a Type2 charstring.

veraPDF truncates a fractional nominalWidthX to an integer when it applies it (measured on TeX subset CFFs: 384.77777 is applied as 384, 501.4375 as 501, so its reported advance is the true advance minus the fractional part). The CFF specification adds the full value, which is what [glyph_width_f64] returns. Both values sit well within the §6.2.11.5 tolerance of ±1 of each other, but a dictionary width that matches the spec value can exceed the tolerance against the validator’s value — so dictionary widths written to satisfy veraPDF must use the same truncated arithmetic.

pub fn glyph_index_by_name(&self, name: &str) -> Option<GlyphId>

Returns a glyph ID by a name.

pub fn default_width_x(&self) -> Option<u16>

Returns the DefaultWidthX value from the Private DICT (SID fonts only).

veraPDF uses this value as the font program width for character codes that are absent from the CFF encoding (i.e., glyph_index returns GID 0).

pub fn default_width_x_f64(&self) -> Option<f64>

Returns the DefaultWidthX value from the Private DICT as f64.

pub fn glyph_name(&self, glyph_id: GlyphId) -> Option<&'a str>

Returns a glyph name.

pub fn glyph_cid(&self, glyph_id: GlyphId) -> Option<u16>

Returns the CID corresponding to a glyph ID.

Returns None if this is not a CIDFont.

pub fn version(&self) -> Option<&str>

Examples found in repository

examples/dump.rs (line 19)

fn main() {
    // open the file passed on the comanmand line
    let path = std::env::args().nth(1).expect("no file given");
    let file = std::fs::File::open(&path).expect("could not open file");
    let mut reader = std::io::BufReader::new(file);
    let mut buffer = Vec::new();
    reader
        .read_to_end(&mut buffer)
        .expect("could not read file");
    let table = Table::parse(&buffer).unwrap();
    dbg!(&table);
    println!("full name: {:?}", table.full_name());
    println!("family name: {:?}", table.family_name());
    println!("version: {:?}", table.version());
    println!("notice: {:?}", table.notice());
    println!("number of glyphs: {:?}", table.number_of_glyphs());

    println!("charset:");
    match table.charset {
        Charset::ISOAdobe => println!("ISOAdobe"),
        Charset::Expert => println!("Expert"),
        Charset::ExpertSubset => println!("ExpertSubset"),
        Charset::Format0(ref array) => {
            println!("Format0:");
            for sid in *array {
                println!("  {:?}", string_by_id(&table, sid));
            }
        }
        Charset::Format1(ref array) => {
            println!("Format1:");
            for range in *array {
                let sid = range.first;
                let count = range.left;
                println!("  {:?} {:?}", sid, count);
                for i in 0..=count {
                    println!(
                        "    {:?}",
                        string_by_id(&table, StringId(sid.0 + u16::from(i)))
                    );
                }
            }
        }
        Charset::Format2(ref array) => {
            println!("Format2:");
            for range in *array {
                let sid = range.first;
                let count = range.left;
                println!("  {:?} {:?}", sid, count);
                for i in 0..=count {
                    println!("    {:?}", string_by_id(&table, StringId(sid.0 + i)));
                }
            }
        }
    }
    println!("encoding:");
    match table.encoding.kind {
        cff_parser::EncodingKind::Standard => println!("Standard"),
        cff_parser::EncodingKind::Expert => println!("Expert"),
        cff_parser::EncodingKind::Format0(ref array) => {
            println!("Format0:");
            for code in *array {
                println!("  {:?}", code);
            }
        }
        cff_parser::EncodingKind::Format1(ref array) => {
            println!("Format1:");
            for range in *array {
                println!("  {:?} {:?}", range.first, range.left);
            }
        }
    }
}

pub fn notice(&self) -> Option<&str>

Examples found in repository

examples/dump.rs (line 20)

fn main() {
    // open the file passed on the comanmand line
    let path = std::env::args().nth(1).expect("no file given");
    let file = std::fs::File::open(&path).expect("could not open file");
    let mut reader = std::io::BufReader::new(file);
    let mut buffer = Vec::new();
    reader
        .read_to_end(&mut buffer)
        .expect("could not read file");
    let table = Table::parse(&buffer).unwrap();
    dbg!(&table);
    println!("full name: {:?}", table.full_name());
    println!("family name: {:?}", table.family_name());
    println!("version: {:?}", table.version());
    println!("notice: {:?}", table.notice());
    println!("number of glyphs: {:?}", table.number_of_glyphs());

    println!("charset:");
    match table.charset {
        Charset::ISOAdobe => println!("ISOAdobe"),
        Charset::Expert => println!("Expert"),
        Charset::ExpertSubset => println!("ExpertSubset"),
        Charset::Format0(ref array) => {
            println!("Format0:");
            for sid in *array {
                println!("  {:?}", string_by_id(&table, sid));
            }
        }
        Charset::Format1(ref array) => {
            println!("Format1:");
            for range in *array {
                let sid = range.first;
                let count = range.left;
                println!("  {:?} {:?}", sid, count);
                for i in 0..=count {
                    println!(
                        "    {:?}",
                        string_by_id(&table, StringId(sid.0 + u16::from(i)))
                    );
                }
            }
        }
        Charset::Format2(ref array) => {
            println!("Format2:");
            for range in *array {
                let sid = range.first;
                let count = range.left;
                println!("  {:?} {:?}", sid, count);
                for i in 0..=count {
                    println!("    {:?}", string_by_id(&table, StringId(sid.0 + i)));
                }
            }
        }
    }
    println!("encoding:");
    match table.encoding.kind {
        cff_parser::EncodingKind::Standard => println!("Standard"),
        cff_parser::EncodingKind::Expert => println!("Expert"),
        cff_parser::EncodingKind::Format0(ref array) => {
            println!("Format0:");
            for code in *array {
                println!("  {:?}", code);
            }
        }
        cff_parser::EncodingKind::Format1(ref array) => {
            println!("Format1:");
            for range in *array {
                println!("  {:?} {:?}", range.first, range.left);
            }
        }
    }
}

pub fn full_name(&self) -> Option<&str>

Examples found in repository

examples/dump.rs (line 17)

fn main() {
    // open the file passed on the comanmand line
    let path = std::env::args().nth(1).expect("no file given");
    let file = std::fs::File::open(&path).expect("could not open file");
    let mut reader = std::io::BufReader::new(file);
    let mut buffer = Vec::new();
    reader
        .read_to_end(&mut buffer)
        .expect("could not read file");
    let table = Table::parse(&buffer).unwrap();
    dbg!(&table);
    println!("full name: {:?}", table.full_name());
    println!("family name: {:?}", table.family_name());
    println!("version: {:?}", table.version());
    println!("notice: {:?}", table.notice());
    println!("number of glyphs: {:?}", table.number_of_glyphs());

    println!("charset:");
    match table.charset {
        Charset::ISOAdobe => println!("ISOAdobe"),
        Charset::Expert => println!("Expert"),
        Charset::ExpertSubset => println!("ExpertSubset"),
        Charset::Format0(ref array) => {
            println!("Format0:");
            for sid in *array {
                println!("  {:?}", string_by_id(&table, sid));
            }
        }
        Charset::Format1(ref array) => {
            println!("Format1:");
            for range in *array {
                let sid = range.first;
                let count = range.left;
                println!("  {:?} {:?}", sid, count);
                for i in 0..=count {
                    println!(
                        "    {:?}",
                        string_by_id(&table, StringId(sid.0 + u16::from(i)))
                    );
                }
            }
        }
        Charset::Format2(ref array) => {
            println!("Format2:");
            for range in *array {
                let sid = range.first;
                let count = range.left;
                println!("  {:?} {:?}", sid, count);
                for i in 0..=count {
                    println!("    {:?}", string_by_id(&table, StringId(sid.0 + i)));
                }
            }
        }
    }
    println!("encoding:");
    match table.encoding.kind {
        cff_parser::EncodingKind::Standard => println!("Standard"),
        cff_parser::EncodingKind::Expert => println!("Expert"),
        cff_parser::EncodingKind::Format0(ref array) => {
            println!("Format0:");
            for code in *array {
                println!("  {:?}", code);
            }
        }
        cff_parser::EncodingKind::Format1(ref array) => {
            println!("Format1:");
            for range in *array {
                println!("  {:?} {:?}", range.first, range.left);
            }
        }
    }
}

pub fn family_name(&self) -> Option<&str>

Examples found in repository

examples/dump.rs (line 18)

fn main() {
    // open the file passed on the comanmand line
    let path = std::env::args().nth(1).expect("no file given");
    let file = std::fs::File::open(&path).expect("could not open file");
    let mut reader = std::io::BufReader::new(file);
    let mut buffer = Vec::new();
    reader
        .read_to_end(&mut buffer)
        .expect("could not read file");
    let table = Table::parse(&buffer).unwrap();
    dbg!(&table);
    println!("full name: {:?}", table.full_name());
    println!("family name: {:?}", table.family_name());
    println!("version: {:?}", table.version());
    println!("notice: {:?}", table.notice());
    println!("number of glyphs: {:?}", table.number_of_glyphs());

    println!("charset:");
    match table.charset {
        Charset::ISOAdobe => println!("ISOAdobe"),
        Charset::Expert => println!("Expert"),
        Charset::ExpertSubset => println!("ExpertSubset"),
        Charset::Format0(ref array) => {
            println!("Format0:");
            for sid in *array {
                println!("  {:?}", string_by_id(&table, sid));
            }
        }
        Charset::Format1(ref array) => {
            println!("Format1:");
            for range in *array {
                let sid = range.first;
                let count = range.left;
                println!("  {:?} {:?}", sid, count);
                for i in 0..=count {
                    println!(
                        "    {:?}",
                        string_by_id(&table, StringId(sid.0 + u16::from(i)))
                    );
                }
            }
        }
        Charset::Format2(ref array) => {
            println!("Format2:");
            for range in *array {
                let sid = range.first;
                let count = range.left;
                println!("  {:?} {:?}", sid, count);
                for i in 0..=count {
                    println!("    {:?}", string_by_id(&table, StringId(sid.0 + i)));
                }
            }
        }
    }
    println!("encoding:");
    match table.encoding.kind {
        cff_parser::EncodingKind::Standard => println!("Standard"),
        cff_parser::EncodingKind::Expert => println!("Expert"),
        cff_parser::EncodingKind::Format0(ref array) => {
            println!("Format0:");
            for code in *array {
                println!("  {:?}", code);
            }
        }
        cff_parser::EncodingKind::Format1(ref array) => {
            println!("Format1:");
            for range in *array {
                println!("  {:?} {:?}", range.first, range.left);
            }
        }
    }
}

Trait Implementations

impl<'a> Clone for Table<'a>

fn clone(&self) -> Table<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for Table<'a>

impl Debug for Table<'_>

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

Formats the value using the given formatter.