Scryber.Core.OpenType 6.0.0-alpha

Scryber.Core.OpenType

This repository is the OpenType library capability for Scryber, but placed independently in case it helps others.

It allows the...

• Reading of multiple font files from various sources,
• Measuring lines of characters within available space using that font.
• The conversion from ttc or woff to open type byte arrays or streams.
• Both syncronous and asyncronous loading of typefaces and fonts.

This latest version (6.0.0-alpha at the time of writing) supports the following frameworks

• .NET Standard 2.0
• .NET Standard 2.1
• .NET Core 3.1
• .NET 5.0
• .NET 6.0 (RC1)
• .NET Framework 4.8

Supported Typeface Formats

The Scryber.Core.OpenType library supports reading typefaces and font programmes in the following formats:

• True Type fonts.
• Open Type fonts (including ccf).
• True Type collections
• Woff fonts (version 1)

Woff2 is coming, but need to resolve the glyph tables back into true type format first.

Using the library

If you want to use the library in your own projects or build on the base library, please feel free. And if you have any troublesome fonts, please just call them out. Happy to help, as it helps us too.

See the read me file at https://github.com/richard-scryber/Scryber.Core.OpenType for more usage information

In this document we use the terms 'Typeface' to refer to a single file or stream, and 'Font' to refer to the one or more font programmes in that file or stream

1. Create a TypefaceReader

The TypefaceReader (Scryber.OpenType.TypefaceReader) is the primary entry point to the library and there are multiple constructors for the disposable class that can read a typeface from either a url, file, stream or custom StreamLoader (Scryber.OpenType.Utility.StreamLoader). The overloads also allow a base path to be defined and also an 'HttpClient or WebClient' to be passed rather than a new one be created on demand by each reader instance.

   //using Scryber.OpenType;

   using(var reader = new TypefaceReader())
   {
   }

2. Reading the information in a typeface file.

Once a reader is created it can be used to read one or more typefaces from a stream, file or url using the ReadTypeface or ReadTypefaceAsync variants.

   //using Scryber.OpenType

   using(var reader = new TypefaceReader())
   {
        var file = new FileInfo("[path to font]"); //new Uri("[absolute or relative url]");
        var face = reader.ReadTypeface(file); //await reader.ReadTypefaceAsync(url);
   }

The library uses the .net framework FileInfo and Uri classes along with the Stream classes to distinguish easily between file paths and urls, rather than trusting strings.

3. Reading font programmes

A TypefaceReader also reads the font programmes within the the files or streams with the GetFont and similar methods, allowing both synchronous and asyncronous loading of font programmes. All methods return either a single or a collection of ITypefaceFont(s) from a previous ITypefaceInfo or IFontInfo, or paths or streams.

   using(var reader = new TypefaceReader())
   {
        var file = new FileInfo("[path to font]"); //new Uri("[absolute or relative url]");
        var font = reader.GetFonts(file); //await reader.GetFontsAsync(url);
   }

The returned ITypefaceFont is also an IFontInfo interface so can be used interchangeably but add functionality for extracting tables, data and getting the font metrics.

There are no TryGetFont methods as the info access should be used to check fonts, and any other failures would point to an invalid font (or an issue with the library).

3.1. The ITypefaceFont

The ITypefaceFont has a GetFileData method that will return a byte[] for the data that can be saved to another stream matching the format requested, if that is supported The CanGetFileData will return true if the conversion would be supported.

It also supports the font metrics using the GetMetrics method.

The returned instances can also support the IOpenTypeFont. This interface enables access to the inner tables in an open/true type font programme, along with any decoded SubTables.

3.2. Extracting the font data

Primarily the ONLY fully supported format is DataFormat.TTF, and will support the conversion if the original source was OpenType, TrueType, TrueTypeCollection, or Woff v1.

   //using System.IO;
   
   using(var reader = new TypefaceReader())
   {
        var file = new FileInfo("[path to font]"); //new Uri("[absolute or relative url]");
        var font = reader.GetFont(file, 0); //await reader.GetFontsAsync(url);

        if(font.CanGetFileData(DataFormat.TTF))
            File.WriteAllBytes("[new path].ttf", font.GetFileData(DataFormat.TTF);
   }

3.3 Supported conversion

The following table shows the input data type and supported output type for an ITypefaceFont.

It may be that we will add more in the future, but it meets the needs of our usage at the moment.

3.4 Measuring strings

The font metrics returned from the ITypefaceFont enables the measurement of strings of characters in a font programme. At the moment it is fairly basic, only supporting horizontal characters, word and character spacing, and word boundaries, nor it does not use the kerning tables.

However it is fast.

   //using System.IO;
   
   using(var reader = new TypefaceReader())
   {
        var file = new FileInfo("[path to font]"); //new Uri("[absolute or relative url]");
        var font = reader.GetFont(file, 0); //await reader.GetFontsAsync(url);

        var options = new TypeMeasureOptions() { BreakOnWordBoundaries = true };

        //Get the standard font metrics for the font.
        var metrics = font.GetMetrics(options);

        var chars = "This is my line of text";
        var start = 0;
        var fontSize = 12.0;
        var max = 200.0;
 
        var size = metrics.MeasureLine(chars, start, fontSize, max, options);

        Console.WriteLine("Fitted " + size.CharsFitted + " in "
                                    + size.RequiredWidth
                                    + (OnWordBoundary ? ", breaking on a word boundary" : ""));
   }

The font metrics instance holds a reference to the font programme, but can also add lookup tables for common and used characters. A single instance can be held to measure any number of font sizes. If multiple fonts are used, they, and the data they contain will not be garbage collected if the measure is still referenced.

5. With thanks

We have referred to a lot of other open source software and libraries to get this code together, and it is with thanks to them that we can have been able to do this.

• iTextSharp in it's various releases,
• SharpZipLib for decompression where decomression is not available
• Typography.OpenFont for the Woff and Woff2 formats

These are brilliant libraries and assets to the open source community.

Happy coding.