public static HoizontalHeadTable Load(FontReader reader)
{
using (var binaryReader = reader.GetReaderAtTablePosition(TableName))
{
return(Load(binaryReader));
}
}
internal Table?Load(string tag, FontReader reader)
{
// loader missing register an unknow type loader and carry on
return(this.loaders.TryGetValue(tag, out Func <FontReader, Table?> func)
? func.Invoke(reader)
: new UnknownTable(tag));
}
public static CMapTable Load(FontReader reader)
{
using (BinaryReader binaryReader = reader.GetReaderAtTablePosition(TableName))
{
return(Load(binaryReader));
}
}
public static MaximumProfileTable Load(FontReader reader)
{
using (var r = reader.GetReaderAtTablePosition(TableName))
{
return(Load(r));
}
}
public static NameTable Load(FontReader reader)
{
using (BinaryReader r = reader.GetReaderAtTablePosition(TableName))
{
// move to start of table
return(Load(r));
}
}
public static SequentialMapGroup FromReader(FontReader reader)
{
var startCharCode = reader.ReadUInt32BigEndian();
var endCharCode = reader.ReadUInt32BigEndian();
var startGlyphId = reader.ReadUInt32BigEndian();
return(new SequentialMapGroup(startCharCode, endCharCode, startGlyphId));
}
public void GlyphsCount_WithWoffFormat_EqualsTtf()
{
var fontReaderWoff = new FontReader(TestFonts.OpensSansWoff1Data());
GlyphTable glyphsWoff = fontReaderWoff.GetTable <GlyphTable>();
var fontReaderTtf = new FontReader(TestFonts.OpenSansTtfData());
GlyphTable glyphsTtf = fontReaderTtf.GetTable <GlyphTable>();
Assert.Equal(glyphsTtf.GlyphCount, glyphsWoff.GlyphCount);
}
public static GlyphTable Load(FontReader reader)
{
var locations = reader.GetTable <IndexLocationTable>().GlyphOffsets;
using (var binaryReader = reader.GetReaderAtTablePosition(TableName))
{
return(Load(binaryReader, locations));
}
}
public static SegmentMappingToDeltaValuesTable FromReader(FontReader reader)
{
var start = reader.Position;
var format = reader.ReadUInt16BigEndian();
var length = reader.ReadUInt16BigEndian();
var language = reader.ReadUInt16BigEndian();
var segCountX2 = reader.ReadUInt16BigEndian();
var searchRange = reader.ReadUInt16BigEndian();
var entrySelector = reader.ReadUInt16BigEndian();
var rangeShift = reader.ReadUInt16BigEndian();
var segCount = segCountX2 / 2;
var endCount = new ushort[segCount];
for (var i = 0; i < endCount.Length; i++)
{
endCount[i] = reader.ReadUInt16BigEndian();
}
var reservedPad = reader.ReadUInt16BigEndian();
var startCount = new ushort[segCount];
for (var i = 0; i < startCount.Length; i++)
{
startCount[i] = reader.ReadUInt16BigEndian();
}
var idDelta = new short[segCount];
for (var i = 0; i < idDelta.Length; i++)
{
idDelta[i] = reader.ReadInt16BigEndian();
}
var idRangeOffset = new ushort[segCount];
for (var i = 0; i < idRangeOffset.Length; i++)
{
idRangeOffset[i] = reader.ReadUInt16BigEndian();
}
var read = start - reader.Position;
var glyphCount = (length - read) / sizeof(ushort);
var glyphIdArray = new ushort[glyphCount];
for (var i = 0; i < glyphIdArray.Length; i++)
{
glyphIdArray[i] = reader.ReadUInt16BigEndian();
}
return(new SegmentMappingToDeltaValuesTable(format, reservedPad, length, language, segCount, searchRange, entrySelector, rangeShift,
endCount, startCount, idDelta, idRangeOffset, glyphCount, glyphIdArray));
}
public static TableRecordEntry FromReader(FontReader reader)
{
var tag = reader.ReadAscii(4);
var checksum = reader.ReadUInt32BigEndian();
var offset = reader.ReadUInt32BigEndian();
var length = reader.ReadUInt32BigEndian();
return(new TableRecordEntry(tag, checksum, offset, length));
}
public static HorizontalMetricsTable Load(FontReader reader)
{
// you should load all dependent tables prior to manipulating the reader
HorizontalHeadTable headTable = reader.GetTable <HorizontalHeadTable>();
MaximumProfileTable profileTable = reader.GetTable <MaximumProfileTable>();
// Move to start of table
using BigEndianBinaryReader binaryReader = reader.GetReaderAtTablePosition(TableName);
return(Load(binaryReader, headTable.NumberOfHMetrics, profileTable.GlyphCount));
}
public void ReadTrueTypeOutlineType()
{
BinaryWriter writer = new BinaryWriter();
writer.WriteTrueTypeFileHeader(0, 0, 0, 0);
FontReader reader = new FontReader(writer.GetStream());
Assert.Equal(FontReader.OutlineTypes.TrueType, reader.OutlineType);
}
internal Table Load(string tag, FontReader reader)
{
// loader missing register an unknow type loader and carry on
if (!this.loaders.ContainsKey(tag))
{
return(new UnknownTable(tag));
}
return(this.loaders[tag]?.Invoke(reader));
}
public static GlyphTable Load(FontReader reader)
{
uint[] locations = reader.GetTable <IndexLocationTable>().GlyphOffsets;
Bounds fallbackEmptyBounds = reader.GetTable <HeadTable>().Bounds;
using (BinaryReader binaryReader = reader.GetReaderAtTablePosition(TableName))
{
return(Load(binaryReader, locations, fallbackEmptyBounds));
}
}
private static KernTable ReadKernTable(FontReader reader, IReadOnlyDictionary <string, TableRecordEntry> entries)
{
if (entries.TryGetValue("kern", out var kernEntry))
{
reader.Seek(kernEntry.Offset);
return(KernTable.FromReader(reader));
}
return(KernTable.Empty);
}
private static CmapTable ReadCmapTable(string path, FontReader reader, IReadOnlyDictionary <string, TableRecordEntry> entries)
{
if (entries.TryGetValue("cmap", out var cmapEntry))
{
reader.Seek(cmapEntry.Offset);
return(CmapTable.FromReader(reader));
}
throw new Exception(
$"Font {path} does not contain a Character To Glyph Index Mapping Table (cmap)");
}
public static HeadTable Load(FontReader reader)
{
using (BinaryReader binaryReader = reader.GetReaderAtTablePosition(TableName))
{
if (binaryReader == null)
{
return(null);
}
return(Load(binaryReader));
}
}
internal TTable Load <TTable>(FontReader reader)
where TTable : Table
{
// loader missing register an unknow type loader and carry on
if (this.typesLoaders.ContainsKey(typeof(TTable)))
{
return((TTable)this.typesLoaders[typeof(TTable)]?.Invoke(reader));
}
throw new Exception("font table not registered");
}
internal TTable?Load <TTable>(FontReader reader)
where TTable : Table
{
// loader missing register an unknow type loader and carry on
if (this.typesLoaders.TryGetValue(typeof(TTable), out Func <FontReader, Table?> func))
{
return((TTable?)func.Invoke(reader));
}
throw new Exception("font table not registered");
}
private static NameTable ReadNameTable(string path, FontReader reader, IReadOnlyDictionary <string, TableRecordEntry> entries)
{
if (entries.TryGetValue("name", out var cmapEntry))
{
reader.Seek(cmapEntry.Offset);
return(NameTable.FromReader(reader));
}
throw new Exception(
$"Font {path} does not contain a Name Table (name)");
}
public void ReadFont_WithWoffFormat_EqualsTtf()
{
var fontReaderTtf = new FontReader(TestFonts.OpenSansTtfData());
var fontReaderWoff = new FontReader(TestFonts.OpensSansWoff1Data());
Assert.Equal(fontReaderTtf.Headers.Count, fontReaderWoff.Headers.Count);
foreach (string key in fontReaderTtf.Headers.Keys)
{
Assert.True(fontReaderWoff.Headers.ContainsKey(key));
}
}
public static IndexLocationTable Load(FontReader reader)
{
var head = reader.GetTable <HeadTable>();
var maxp = reader.GetTable <MaximumProfileTable>();
// must not get a binary reader untill all depended data is retrieved in case they need to use the stream
using (var binaryReader = reader.GetReaderAtTablePosition(TableName))
{
return(Load(binaryReader, maxp.GlyphCount, head.IndexLocationFormat));
}
}
public void ReadCcfOutlineType()
{
BinaryWriter writer = new BinaryWriter();
writer.WriteCffFileHeader(0, 0, 0, 0);
Assert.Throws <Exceptions.InvalidFontFileException>(
() =>
{
FontReader reader = new FontReader(writer.GetStream());
});
}
public static ColrTable?Load(FontReader reader)
{
using (var binaryReader = reader.TryGetReaderAtTablePosition(TableName))
{
if (binaryReader == null)
{
return(null);
}
return(Load(binaryReader));
}
}
public static OS2Table?Load(FontReader reader)
{
using (BinaryReader? r = reader.TryGetReaderAtTablePosition(TableName))
{
if (r is null)
{
return(null);
}
return(Load(r));
}
}
public static OS2Table?Load(FontReader fontReader)
{
if (!fontReader.TryGetReaderAtTablePosition(TableName, out BigEndianBinaryReader? binaryReader))
{
return(null);
}
using (binaryReader)
{
return(Load(binaryReader));
}
}
public static OS2Table Load(FontReader reader)
{
using (var r = reader.GetReaderAtTablePosition(TableName))
{
if (r == null)
{
return(null);
}
return(Load(r));
}
}
public static HorizontalHeadTable?Load(FontReader reader)
{
using (BinaryReader? binaryReader = reader.TryGetReaderAtTablePosition(TableName))
{
if (binaryReader == null)
{
return(null);
}
return(Load(binaryReader));
}
}
public void ReadTableHeaders()
{
BinaryWriter writer = new BinaryWriter();
writer.WriteTrueTypeFileHeader(2, 0, 0, 0);
writer.WriteTableHeader("name", 0, 10, 0);
writer.WriteTableHeader("cmap", 0, 1, 0);
FontReader reader = new FontReader(writer.GetStream());
Assert.Equal(2, reader.Headers.Count);
}
public static TrueTypeFont FromFile(string path)
{
using (var reader = new FontReader(File.OpenRead(path)))
{
var offsetTable = OffsetTable.FromReader(reader);
var entries = ReadTableRecords(reader, offsetTable);
var cmap = ReadCmapTable(path, reader, entries);
var name = ReadNameTable(path, reader, entries);
var kern = ReadKernTable(reader, entries);
return(new TrueTypeFont(path, offsetTable, entries, cmap, name, kern));
}
}