From a9ec47f2294781405ccfd7de39dc9fec6fa29800 Mon Sep 17 00:00:00 2001
From: swmal <897655+swmal@users.noreply.github.com>
Date: Wed, 14 Jan 2026 16:13:55 +0100
Subject: [PATCH 01/18] Milestone: first version with subsetting support using
GSUB and GPOS
---
.../Helpers/FontTestHelper.cs | 4 +-
.../Regression/RegressionTests.cs | 6 +-
.../Serialization/CmapSerializationTests.cs | 2 +-
.../Serialization/GPosSerializationTests.cs | 876 ++++++++++++++++++
.../Subsetting/BasicSubsettingTests.cs | 55 +-
.../FontTableReaderFactory.cs | 29 +
src/EPPlus.Fonts.OpenType/OpenTypeFont.cs | 82 +-
.../OpenTypeFontFactory.cs | 6 +-
.../OpenTypeFontSerializer.cs | 97 +-
src/EPPlus.Fonts.OpenType/OpenTypeFonts.cs | 1 +
.../Layout/Features/FeatureListTable.cs | 54 +-
.../Layout/Features/FeatureRewriteResult.cs | 22 +
.../Common/Layout/Scripts/ScriptListTable.cs | 144 +--
.../Tables/Gpos/GposTable.cs | 48 +-
.../Tables/Gsub/GsubTable.cs | 52 +-
.../Tables/TableCache.cs | 84 +-
.../Tables/TableLoader.cs | 50 +-
.../Tables/TableLoaderCache.cs | 53 ++
.../Tables/TableLoaderSettings.cs | 19 +-
.../Tables/TableLoaders.cs | 135 ++-
20 files changed, 1573 insertions(+), 246 deletions(-)
create mode 100644 src/EPPlus.Fonts.OpenType.Tests/Serialization/GPosSerializationTests.cs
create mode 100644 src/EPPlus.Fonts.OpenType/FontTableReaderFactory.cs
create mode 100644 src/EPPlus.Fonts.OpenType/Tables/Common/Layout/Features/FeatureRewriteResult.cs
create mode 100644 src/EPPlus.Fonts.OpenType/Tables/TableLoaderCache.cs
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Helpers/FontTestHelper.cs b/src/EPPlus.Fonts.OpenType.Tests/Helpers/FontTestHelper.cs
index 6ab54fde9..aa84e0d5d 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Helpers/FontTestHelper.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Helpers/FontTestHelper.cs
@@ -120,7 +120,7 @@ public static OpenTypeFont RoundtripSubset(
var bytes = subset.Serialize();
var parsed = new OpenTypeFont(
- new FontsBinaryReader(new MemoryStream(bytes)),
+ bytes,
font.Format);
AssertFontValid(parsed);
@@ -141,7 +141,7 @@ public static OpenTypeFont RoundtripSubset(
var bytes = subset.Serialize();
var parsed = new OpenTypeFont(
- new FontsBinaryReader(new MemoryStream(bytes)),
+ bytes,
font.Format);
AssertFontValid(parsed);
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Regression/RegressionTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Regression/RegressionTests.cs
index 4134259d2..69b1a3d06 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Regression/RegressionTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Regression/RegressionTests.cs
@@ -53,7 +53,7 @@ public void Bug_20251222_CircularLigatureDependency_Roboto()
// Should create valid font with ffi ligature
var bytes = subset.Serialize();
- var parsed = new OpenTypeFont(new FontsBinaryReader(new MemoryStream(bytes)), font.Format);
+ var parsed = new OpenTypeFont(bytes, font.Format);
Assert.IsNotNull(parsed.GsubTable);
@@ -157,7 +157,7 @@ public void Bug_20251222_LigatureComponentRewrite_WrongDictionary()
// Serialize and re-parse to verify components are correct
var bytes = subset.Serialize();
- var parsed = new OpenTypeFont(new FontsBinaryReader(new MemoryStream(bytes)), font.Format);
+ var parsed = new OpenTypeFont(bytes, font.Format);
// Should have fi ligature with correctly remapped components
int ligCount = FontTestHelper.CountLigatures(parsed);
@@ -226,7 +226,7 @@ public void Bug_20251222_MissingCoverageInitialization()
Assert.IsTrue(bytes.Length > 0);
// Should parse successfully
- var parsed = new OpenTypeFont(new FontsBinaryReader(new MemoryStream(bytes)), font.Format);
+ var parsed = new OpenTypeFont(bytes, font.Format);
Assert.IsNotNull(parsed);
FontTestHelper.AssertFontValid(parsed);
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Serialization/CmapSerializationTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Serialization/CmapSerializationTests.cs
index 18c4eb6ec..e964a734d 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Serialization/CmapSerializationTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Serialization/CmapSerializationTests.cs
@@ -46,7 +46,7 @@ public void SerializeCmapTable_Format12()
// re-serialize
var bytes = font.CmapTable.Serialize(font);
- var tempFont = new OpenTypeFont(new FontsBinaryReader(new MemoryStream(bytes)), font.Format);
+ var tempFont = new OpenTypeFont(bytes, font.Format);
// Check that ALL original chars are still there
foreach (uint cp in allCodePoints)
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Serialization/GPosSerializationTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Serialization/GPosSerializationTests.cs
new file mode 100644
index 000000000..81af10661
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType.Tests/Serialization/GPosSerializationTests.cs
@@ -0,0 +1,876 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/13/2026 EPPlus Software AB GPOS serialization tests (semantic validation)
+ *************************************************************************************************/
+using EPPlus.Fonts.OpenType.Tables.Common.Layout.Coverage;
+using EPPlus.Fonts.OpenType.Tables.Common.Layout.Lookups;
+using EPPlus.Fonts.OpenType.Tables.Gpos;
+using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups;
+using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups.LookupType1;
+using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups.LookupType2;
+using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups.LookupType4;
+using EPPlus.Fonts.OpenType.Tests.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+
+namespace EPPlus.Fonts.OpenType.Tests.Serialization
+{
+ ///
+ /// Tests for GPOS table serialization with semantic validation.
+ /// These tests verify that positioning data survives roundtrip serialization,
+ /// without requiring byte-perfect output (Format 2 may be expanded to Format 1, etc.)
+ ///
+ [TestClass]
+ public class GposSerializationTests : FontTestBase
+ {
+ [ClassInitialize]
+ public static void Initialize(TestContext testContext)
+ {
+ FontDirectoriesTestHelper.ClassInitialize(testContext);
+ }
+
+ #region Helper Classes for .NET 3.5 Compatibility
+
+ ///
+ /// Represents a glyph pair key for kerning lookups
+ ///
+ private class GlyphPair
+ {
+ public ushort FirstGlyph { get; set; }
+ public ushort SecondGlyph { get; set; }
+
+ public GlyphPair(ushort first, ushort second)
+ {
+ FirstGlyph = first;
+ SecondGlyph = second;
+ }
+
+ public override bool Equals(object obj)
+ {
+ var other = obj as GlyphPair;
+ if (other == null) return false;
+ return FirstGlyph == other.FirstGlyph && SecondGlyph == other.SecondGlyph;
+ }
+
+ public override int GetHashCode()
+ {
+ return (FirstGlyph << 16) | SecondGlyph;
+ }
+ }
+
+ ///
+ /// Represents anchor point data for mark-to-base attachments
+ ///
+ private class AnchorPointPair
+ {
+ public short MarkAnchorX { get; set; }
+ public short MarkAnchorY { get; set; }
+ public short BaseAnchorX { get; set; }
+ public short BaseAnchorY { get; set; }
+ }
+
+ ///
+ /// Represents a single position adjustment
+ ///
+ private class SinglePosValue
+ {
+ public short XPlacement { get; set; }
+ public short YPlacement { get; set; }
+ public short XAdvance { get; set; }
+ public short YAdvance { get; set; }
+ }
+
+ #endregion
+
+ [TestMethod]
+ public void Diagnose_SerializedFontOffsets()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular, ignoreCache: true);
+
+ Debug.WriteLine("=== ORIGINAL TABLE RECORDS ===");
+ foreach (var kvp in font.TableRecords)
+ {
+ Debug.WriteLine(string.Format("{0}: Offset={1}, Length={2}",
+ kvp.Key, kvp.Value.Offset, kvp.Value.Length));
+ }
+
+ // Act
+ var serializer = new OpenTypeFontSerializer(font);
+ var bytes = serializer.Serialize();
+
+ Debug.WriteLine(string.Format("\n=== SERIALIZED FONT: {0} bytes ===", bytes.Length));
+
+ // Read back table directory from serialized bytes
+ using (var ms = new MemoryStream(bytes))
+ using (var reader = new FontsBinaryReader(ms))
+ {
+ // Skip sfnt header (12 bytes)
+ reader.BaseStream.Position = 0;
+ uint sfntVersion = reader.ReadUInt32BigEndian();
+ ushort numTables = reader.ReadUInt16BigEndian();
+ reader.ReadUInt16BigEndian(); // searchRange
+ reader.ReadUInt16BigEndian(); // entrySelector
+ reader.ReadUInt16BigEndian(); // rangeShift
+
+ Debug.WriteLine(string.Format("\nsfntVersion: 0x{0:X8}", sfntVersion));
+ Debug.WriteLine(string.Format("numTables: {0}", numTables));
+
+ Debug.WriteLine("\n=== SERIALIZED TABLE RECORDS ===");
+ for (int i = 0; i < numTables; i++)
+ {
+ byte[] tagBytes = reader.ReadBytes(4);
+ string tag = System.Text.Encoding.ASCII.GetString(tagBytes);
+ uint checksum = reader.ReadUInt32BigEndian();
+ uint offset = reader.ReadUInt32BigEndian();
+ uint length = reader.ReadUInt32BigEndian();
+
+ string status = "";
+ if (offset + length > bytes.Length)
+ {
+ status = " *** INVALID: extends beyond file!";
+ }
+
+ Debug.WriteLine(string.Format("{0}: Offset={1}, Length={2}{3}",
+ tag, offset, length, status));
+ }
+ }
+ }
+
+ #region Structure Preservation Tests
+
+ [TestMethod]
+ public void SerializeGpos_StructurePreserved()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular, ignoreCache: true);
+ var originalGpos = font.GposTable;
+
+ // Act
+ var serializer = new OpenTypeFontSerializer(font);
+ var bytes = serializer.Serialize();
+ var reparsed = new OpenTypeFont(bytes, font.Format);
+
+ // Assert - Structure
+ Assert.IsNotNull(reparsed.GposTable, "GPOS table should exist after roundtrip");
+ Assert.AreEqual(originalGpos.MajorVersion, reparsed.GposTable.MajorVersion);
+ Assert.AreEqual(originalGpos.MinorVersion, reparsed.GposTable.MinorVersion);
+
+ // Script count
+ Assert.AreEqual(
+ originalGpos.ScriptList.ScriptRecords.Count,
+ reparsed.GposTable.ScriptList.ScriptRecords.Count,
+ "Script count should match");
+
+ // Feature count
+ Assert.AreEqual(
+ originalGpos.FeatureList.FeatureRecords.Count,
+ reparsed.GposTable.FeatureList.FeatureRecords.Count,
+ "Feature count should match");
+
+ // Lookup count
+ Assert.AreEqual(
+ originalGpos.LookupList.Lookups.Count,
+ reparsed.GposTable.LookupList.Lookups.Count,
+ "Lookup count should match");
+
+ // Lookup types should match
+ for (int i = 0; i < originalGpos.LookupList.Lookups.Count; i++)
+ {
+ Assert.AreEqual(
+ originalGpos.LookupList.Lookups[i].LookupType,
+ reparsed.GposTable.LookupList.Lookups[i].LookupType,
+ string.Format("Lookup[{0}] type should match", i));
+ }
+ }
+
+ [TestMethod]
+ public void SerializeGpos_FeatureTagsPreserved()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+
+ var originalTags = new List();
+ foreach (var feature in font.GposTable.FeatureList.FeatureRecords)
+ {
+ originalTags.Add(feature.FeatureTag.Value);
+ }
+ originalTags.Sort();
+
+ // Act
+ var serializer = new OpenTypeFontSerializer(font);
+ var bytes = serializer.Serialize();
+ var reparsed = new OpenTypeFont(bytes, font.Format);
+
+ var reparsedTags = new List();
+ foreach (var feature in reparsed.GposTable.FeatureList.FeatureRecords)
+ {
+ reparsedTags.Add(feature.FeatureTag.Value);
+ }
+ reparsedTags.Sort();
+
+ // Assert
+ Assert.AreEqual(originalTags.Count, reparsedTags.Count, "Feature count should match");
+ for (int i = 0; i < originalTags.Count; i++)
+ {
+ Assert.AreEqual(originalTags[i], reparsedTags[i],
+ string.Format("Feature tag[{0}] should match", i));
+ }
+
+ Debug.WriteLine(string.Format("Features preserved: {0}", string.Join(", ", reparsedTags.ToArray())));
+ }
+
+ [TestMethod]
+ public void SerializeGpos_ScriptTagsPreserved()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular, ignoreCache: true);
+
+ var originalTags = new List();
+ foreach (var script in font.GposTable.ScriptList.ScriptRecords)
+ {
+ originalTags.Add(script.ScriptTag.Value);
+ }
+ originalTags.Sort();
+
+ // Act
+ var serializer = new OpenTypeFontSerializer(font);
+ var bytes = serializer.Serialize();
+ var reparsed = new OpenTypeFont(bytes, font.Format);
+
+ var reparsedTags = new List();
+ foreach (var script in reparsed.GposTable.ScriptList.ScriptRecords)
+ {
+ reparsedTags.Add(script.ScriptTag.Value);
+ }
+ reparsedTags.Sort();
+
+ // Assert
+ Assert.AreEqual(originalTags.Count, reparsedTags.Count, "Script count should match");
+ for (int i = 0; i < originalTags.Count; i++)
+ {
+ Assert.AreEqual(originalTags[i], reparsedTags[i],
+ string.Format("Script tag[{0}] should match", i));
+ }
+
+ Debug.WriteLine(string.Format("Scripts preserved: {0}", string.Join(", ", reparsedTags.ToArray())));
+ }
+
+ #endregion
+
+ #region PairPos (Type 2) Kerning Tests
+
+ [TestMethod]
+ public void SerializeGpos_PairPos_KerningValuesPreserved()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular, ignoreCache: true);
+
+ // Collect original kerning pairs
+ var originalKerning = CollectKerningPairs(font);
+ Debug.WriteLine(string.Format("Original font has {0} kerning pairs", originalKerning.Count));
+
+ Assert.IsTrue(originalKerning.Count > 0, "Font should have kerning pairs");
+
+ // Act
+ var serializer = new OpenTypeFontSerializer(font);
+ var bytes = serializer.Serialize();
+ var reparsed = new OpenTypeFont(bytes, font.Format);
+
+ // Assert - All kerning values should be preserved
+ var reparsedKerning = CollectKerningPairs(reparsed);
+
+ Assert.AreEqual(originalKerning.Count, reparsedKerning.Count,
+ "Kerning pair count should match");
+
+ int verified = 0;
+ foreach (var pair in originalKerning.Keys)
+ {
+ short expectedValue = originalKerning[pair];
+
+ Assert.IsTrue(reparsedKerning.ContainsKey(pair),
+ string.Format("Missing kerning pair ({0}, {1})", pair.FirstGlyph, pair.SecondGlyph));
+
+ short actualValue = reparsedKerning[pair];
+ Assert.AreEqual(expectedValue, actualValue,
+ string.Format("Kerning value mismatch for ({0}, {1}): expected {2}, got {3}",
+ pair.FirstGlyph, pair.SecondGlyph, expectedValue, actualValue));
+
+ verified++;
+ }
+
+ Debug.WriteLine(string.Format("Verified {0} kerning pairs", verified));
+ }
+
+ [TestMethod]
+ public void SerializeGpos_PairPos_SpecificPairsVerified()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular, ignoreCache: true);
+
+ // Get glyph IDs for test characters
+ ushort fGlyph, eGlyph, aGlyph, vGlyph;
+ font.CmapTable.TryGetGlyphId('f', out fGlyph);
+ font.CmapTable.TryGetGlyphId('e', out eGlyph);
+ font.CmapTable.TryGetGlyphId('A', out aGlyph);
+ font.CmapTable.TryGetGlyphId('V', out vGlyph);
+
+ // Get original values
+ var origLookup = FindFirstLookupOfType(font.GposTable, 2);
+ Assert.IsNotNull(origLookup, "Should have PairPos lookup");
+
+ var origSubtable = origLookup.SubTables[0] as PairPosSubTableFormat1;
+ Assert.IsNotNull(origSubtable, "Should have PairPos Format 1 subtable");
+
+ ValueRecord feOrig1, feOrig2, avOrig1, avOrig2;
+ bool hasFe = origSubtable.TryGetPairAdjustment(fGlyph, eGlyph, out feOrig1, out feOrig2);
+ bool hasAv = origSubtable.TryGetPairAdjustment(aGlyph, vGlyph, out avOrig1, out avOrig2);
+
+ if (hasFe)
+ {
+ Debug.WriteLine(string.Format("Original: f-e = {0}", feOrig1.XAdvance));
+ }
+ if (hasAv)
+ {
+ Debug.WriteLine(string.Format("Original: A-V = {0}", avOrig1.XAdvance));
+ }
+
+ // Act
+ var serializer = new OpenTypeFontSerializer(font);
+ var bytes = serializer.Serialize();
+ var reparsed = new OpenTypeFont(bytes, font.Format);
+
+ // Assert
+ var newLookup = FindFirstLookupOfType(reparsed.GposTable, 2);
+ Assert.IsNotNull(newLookup, "Reparsed should have PairPos lookup");
+
+ var newSubtable = newLookup.SubTables[0] as PairPosSubTableFormat1;
+ Assert.IsNotNull(newSubtable, "Reparsed should have PairPos Format 1 subtable");
+
+ if (hasFe)
+ {
+ ValueRecord feNew1, feNew2;
+ Assert.IsTrue(newSubtable.TryGetPairAdjustment(fGlyph, eGlyph, out feNew1, out feNew2),
+ "f-e pair should exist");
+ Assert.AreEqual(feOrig1.XAdvance, feNew1.XAdvance, "f-e kerning should match");
+ Debug.WriteLine(string.Format("f-e: {0} verified", feNew1.XAdvance));
+ }
+
+ if (hasAv)
+ {
+ ValueRecord avNew1, avNew2;
+ Assert.IsTrue(newSubtable.TryGetPairAdjustment(aGlyph, vGlyph, out avNew1, out avNew2),
+ "A-V pair should exist");
+ Assert.AreEqual(avOrig1.XAdvance, avNew1.XAdvance, "A-V kerning should match");
+ Debug.WriteLine(string.Format("A-V: {0} verified", avNew1.XAdvance));
+ }
+ }
+
+ [TestMethod]
+ public void SerializeGpos_PairPos_ValueFormatPreserved()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular, ignoreCache: true);
+
+ var origLookup = FindFirstLookupOfType(font.GposTable, 2);
+ var origSubtable = origLookup.SubTables[0] as PairPosSubTableFormat1;
+
+ // Act
+ var serializer = new OpenTypeFontSerializer(font);
+ var bytes = serializer.Serialize();
+ var reparsed = new OpenTypeFont(bytes, font.Format);
+
+ var newLookup = FindFirstLookupOfType(reparsed.GposTable, 2);
+ var newSubtable = newLookup.SubTables[0] as PairPosSubTableFormat1;
+
+ // Assert
+ Assert.AreEqual(origSubtable.ValueFormat1, newSubtable.ValueFormat1,
+ "ValueFormat1 should be preserved");
+ Assert.AreEqual(origSubtable.ValueFormat2, newSubtable.ValueFormat2,
+ "ValueFormat2 should be preserved");
+
+ Debug.WriteLine(string.Format("ValueFormat1: 0x{0:X4}", newSubtable.ValueFormat1));
+ Debug.WriteLine(string.Format("ValueFormat2: 0x{0:X4}", newSubtable.ValueFormat2));
+ }
+
+ #endregion
+
+ #region SinglePos (Type 1) Tests
+
+ [TestMethod]
+ public void SerializeGpos_SinglePos_ValuesPreserved()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular, ignoreCache: true);
+
+ var singlePosLookup = FindFirstLookupOfType(font.GposTable, 1);
+ if (singlePosLookup == null)
+ {
+ Assert.Inconclusive("Roboto does not have SinglePos lookups");
+ return;
+ }
+
+ // Collect original adjustments
+ var originalAdjustments = CollectSinglePosAdjustments(font);
+ Debug.WriteLine(string.Format("Original has {0} single adjustments", originalAdjustments.Count));
+
+ // Act
+ var serializer = new OpenTypeFontSerializer(font);
+ var bytes = serializer.Serialize();
+ var reparsed = new OpenTypeFont(bytes, font.Format);
+
+ // Assert
+ var reparsedAdjustments = CollectSinglePosAdjustments(reparsed);
+
+ Assert.AreEqual(originalAdjustments.Count, reparsedAdjustments.Count,
+ "SinglePos adjustment count should match");
+
+ foreach (ushort glyphId in originalAdjustments.Keys)
+ {
+ var expected = originalAdjustments[glyphId];
+
+ Assert.IsTrue(reparsedAdjustments.ContainsKey(glyphId),
+ string.Format("Missing adjustment for glyph {0}", glyphId));
+
+ var actual = reparsedAdjustments[glyphId];
+
+ Assert.AreEqual(expected.XPlacement, actual.XPlacement,
+ string.Format("Glyph {0} XPlacement", glyphId));
+ Assert.AreEqual(expected.YPlacement, actual.YPlacement,
+ string.Format("Glyph {0} YPlacement", glyphId));
+ Assert.AreEqual(expected.XAdvance, actual.XAdvance,
+ string.Format("Glyph {0} XAdvance", glyphId));
+ Assert.AreEqual(expected.YAdvance, actual.YAdvance,
+ string.Format("Glyph {0} YAdvance", glyphId));
+ }
+
+ Debug.WriteLine(string.Format("Verified {0} single adjustments", originalAdjustments.Count));
+ }
+
+ #endregion
+
+ #region MarkToBase (Type 4) Tests
+
+ [TestMethod]
+ public void SerializeGpos_MarkToBase_StructurePreserved()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular, ignoreCache: true);
+
+ var markToBaseLookup = FindFirstLookupOfType(font.GposTable, 4);
+ if (markToBaseLookup == null)
+ {
+ Assert.Inconclusive("Roboto does not have MarkToBase lookups");
+ return;
+ }
+
+ var origSubtable = markToBaseLookup.SubTables[0] as MarkToBaseSubTableFormat1;
+ Assert.IsNotNull(origSubtable, "Should have MarkToBase subtable");
+
+ // Act
+ var serializer = new OpenTypeFontSerializer(font);
+ var bytes = serializer.Serialize();
+ var reparsed = new OpenTypeFont(bytes, font.Format);
+
+ // Assert
+ var newLookup = FindFirstLookupOfType(reparsed.GposTable, 4);
+ Assert.IsNotNull(newLookup, "MarkToBase lookup should exist");
+
+ var newSubtable = newLookup.SubTables[0] as MarkToBaseSubTableFormat1;
+ Assert.IsNotNull(newSubtable, "MarkToBase subtable should exist");
+
+ Assert.AreEqual(origSubtable.MarkClassCount, newSubtable.MarkClassCount, "MarkClassCount");
+ Assert.AreEqual(origSubtable.MarkArray.MarkCount, newSubtable.MarkArray.MarkCount, "MarkCount");
+ Assert.AreEqual(origSubtable.BaseArray.BaseCount, newSubtable.BaseArray.BaseCount, "BaseCount");
+
+ Debug.WriteLine(string.Format("MarkToBase preserved: {0} classes, {1} marks, {2} bases",
+ newSubtable.MarkClassCount,
+ newSubtable.MarkArray.MarkCount,
+ newSubtable.BaseArray.BaseCount));
+ }
+
+ [TestMethod]
+ public void SerializeGpos_MarkToBase_AnchorPointsPreserved()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular, ignoreCache: true);
+
+ var markToBaseLookup = FindFirstLookupOfType(font.GposTable, 4);
+ if (markToBaseLookup == null)
+ {
+ Assert.Inconclusive("Roboto does not have MarkToBase lookups");
+ return;
+ }
+
+ var origSubtable = markToBaseLookup.SubTables[0] as MarkToBaseSubTableFormat1;
+
+ // Find valid mark-base pairs
+ var originalAttachments = CollectMarkToBaseAttachments(origSubtable);
+ if (originalAttachments.Count == 0)
+ {
+ Assert.Inconclusive("No attachments found");
+ return;
+ }
+
+ Debug.WriteLine(string.Format("Found {0} mark-base attachments", originalAttachments.Count));
+
+ // Act
+ var serializer = new OpenTypeFontSerializer(font);
+ var bytes = serializer.Serialize();
+ var reparsed = new OpenTypeFont(bytes, font.Format);
+
+ // Assert
+ var newLookup = FindFirstLookupOfType(reparsed.GposTable, 4);
+ var newSubtable = newLookup.SubTables[0] as MarkToBaseSubTableFormat1;
+
+ int verified = 0;
+ int maxToVerify = 50;
+
+ foreach (var pair in originalAttachments.Keys)
+ {
+ if (verified >= maxToVerify) break;
+
+ var expected = originalAttachments[pair];
+
+ AnchorTable newMarkAnchor, newBaseAnchor;
+ Assert.IsTrue(newSubtable.TryGetAttachment(pair.FirstGlyph, pair.SecondGlyph,
+ out newMarkAnchor, out newBaseAnchor),
+ string.Format("Missing attachment for mark {0}, base {1}",
+ pair.FirstGlyph, pair.SecondGlyph));
+
+ Assert.AreEqual(expected.MarkAnchorX, newMarkAnchor.XCoordinate,
+ string.Format("Mark anchor X for ({0}, {1})", pair.FirstGlyph, pair.SecondGlyph));
+ Assert.AreEqual(expected.MarkAnchorY, newMarkAnchor.YCoordinate,
+ string.Format("Mark anchor Y for ({0}, {1})", pair.FirstGlyph, pair.SecondGlyph));
+ Assert.AreEqual(expected.BaseAnchorX, newBaseAnchor.XCoordinate,
+ string.Format("Base anchor X for ({0}, {1})", pair.FirstGlyph, pair.SecondGlyph));
+ Assert.AreEqual(expected.BaseAnchorY, newBaseAnchor.YCoordinate,
+ string.Format("Base anchor Y for ({0}, {1})", pair.FirstGlyph, pair.SecondGlyph));
+
+ verified++;
+ }
+
+ Debug.WriteLine(string.Format("Verified {0} anchor point pairs", verified));
+ }
+
+ #endregion
+
+ #region Feature-Lookup Index Integrity Tests
+
+ [TestMethod]
+ public void SerializeGpos_FeatureLookupIndices_AreValid()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular, ignoreCache: true);
+
+ // Act
+ var serializer = new OpenTypeFontSerializer(font);
+ var bytes = serializer.Serialize();
+ var reparsed = new OpenTypeFont(bytes, font.Format);
+
+ // Assert
+ int lookupCount = reparsed.GposTable.LookupList.Lookups.Count;
+
+ foreach (var feature in reparsed.GposTable.FeatureList.FeatureRecords)
+ {
+ foreach (var idx in feature.FeatureTable.LookupListIndices)
+ {
+ Assert.IsTrue(idx < lookupCount,
+ string.Format("Feature '{0}' references invalid lookup index {1} (max={2})",
+ feature.FeatureTag.Value, idx, lookupCount - 1));
+ }
+ }
+
+ Debug.WriteLine(string.Format("All feature->lookup indices valid (max index: {0})", lookupCount - 1));
+ }
+
+ [TestMethod]
+ public void Diagnose_GposTableOffset()
+ {
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+
+ Debug.WriteLine("=== TABLE RECORDS ===");
+ foreach (var kvp in font.TableRecords)
+ {
+ Debug.WriteLine(string.Format("{0}: Offset={1}, Length={2}",
+ kvp.Key, kvp.Value.Offset, kvp.Value.Length));
+ }
+
+ Debug.WriteLine(string.Format("\n=== READER STATE ==="));
+ Debug.WriteLine(string.Format("Reader stream length: {0}", font._tblSettings.TableReaderFactory.FontBytesLength));
+ Debug.WriteLine(string.Format("Reader stream position: {0}", font._tblSettings.TableReaderFactory.FontBytesLength));
+
+ // Try to read GPOS
+ Debug.WriteLine("\n=== LOADING GPOS ===");
+ var gpos = font.GposTable;
+ Debug.WriteLine(string.Format("GPOS version: {0}.{1}", gpos.MajorVersion, gpos.MinorVersion));
+ }
+
+ [TestMethod]
+ public void SerializeGpos_LangSysFeatureIndices_AreValid()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+
+ // Act
+ var serializer = new OpenTypeFontSerializer(font);
+ var bytes = serializer.Serialize();
+ var reparsed = new OpenTypeFont(bytes, font.Format);
+
+ // Assert
+ int featureCount = reparsed.GposTable.FeatureList.FeatureRecords.Count;
+
+ foreach (var script in reparsed.GposTable.ScriptList.ScriptRecords)
+ {
+ // Check DefaultLangSys
+ if (script.ScriptTable.DefaultLangSys != null)
+ {
+ foreach (var idx in script.ScriptTable.DefaultLangSys.FeatureIndices)
+ {
+ Assert.IsTrue(idx < featureCount,
+ string.Format("Script '{0}' DefaultLangSys references invalid feature index {1}",
+ script.ScriptTag.Value, idx));
+ }
+ }
+
+ // Check other LangSys records
+ foreach (var langSys in script.ScriptTable.LangSysRecords)
+ {
+ foreach (var idx in langSys.LangSysTable.FeatureIndices)
+ {
+ Assert.IsTrue(idx < featureCount,
+ string.Format("Script '{0}' LangSys '{1}' references invalid feature index {2}",
+ script.ScriptTag.Value, langSys.LangSysTag, idx));
+ }
+ }
+ }
+
+ Debug.WriteLine(string.Format("All LangSys->feature indices valid (max index: {0})", featureCount - 1));
+ }
+
+ #endregion
+
+ #region Coverage Table Integrity Tests
+
+ [TestMethod]
+ public void SerializeGpos_CoverageGlyphIds_AreValid()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular, ignoreCache: true);
+
+ // Act
+ var serializer = new OpenTypeFontSerializer(font);
+ var bytes = serializer.Serialize();
+ var reparsed = new OpenTypeFont(bytes, font.Format);
+
+ // Assert
+ ushort maxGlyph = reparsed.MaxpTable.numGlyphs;
+
+ for (int lookupIdx = 0; lookupIdx < reparsed.GposTable.LookupList.Lookups.Count; lookupIdx++)
+ {
+ var lookup = reparsed.GposTable.LookupList.Lookups[lookupIdx];
+
+ for (int subtableIdx = 0; subtableIdx < lookup.SubTables.Count; subtableIdx++)
+ {
+ var subtable = lookup.SubTables[subtableIdx];
+ var coverages = GetCoveragesFromSubtable(subtable);
+
+ foreach (var coverage in coverages)
+ {
+ var glyphIds = coverage.GetCoveredGlyphs();
+ foreach (var glyphId in glyphIds)
+ {
+ Assert.IsTrue(glyphId < maxGlyph,
+ string.Format("Lookup type {0} subtable {1}: Coverage references invalid glyph {2} (max={3})",
+ lookup.LookupType, subtableIdx, glyphId, maxGlyph - 1));
+ }
+ }
+ }
+ }
+
+ Debug.WriteLine(string.Format("All coverage glyph IDs valid (max glyph: {0})", maxGlyph - 1));
+ }
+
+ #endregion
+
+ #region Helper Methods
+
+ private LookupTable FindFirstLookupOfType(GposTable gpos, int lookupType)
+ {
+ if (gpos == null) return null;
+
+ foreach (var lookup in gpos.LookupList.Lookups)
+ {
+ if (lookup.LookupType == lookupType)
+ {
+ return lookup;
+ }
+ }
+ return null;
+ }
+
+ private Dictionary CollectKerningPairs(OpenTypeFont font)
+ {
+ var result = new Dictionary();
+
+ var pairPosLookup = FindFirstLookupOfType(font.GposTable, 2);
+ if (pairPosLookup == null) return result;
+
+ foreach (var subtableObj in pairPosLookup.SubTables)
+ {
+ var subtable = subtableObj as PairPosSubTableFormat1;
+ if (subtable == null) continue;
+
+ var coveredGlyphs = subtable.Coverage.GetCoveredGlyphs();
+
+ // PairSets är en List som är indexerad parallellt med Coverage
+ for (int i = 0; i < coveredGlyphs.Length && i < subtable.PairSets.Count; i++)
+ {
+ ushort firstGlyph = coveredGlyphs[i];
+ var pairSet = subtable.PairSets[i];
+
+ if (pairSet == null) continue;
+
+ foreach (var pair in pairSet.PairValueRecords)
+ {
+ var key = new GlyphPair(firstGlyph, pair.SecondGlyph);
+ result[key] = pair.Value1.XAdvance;
+ }
+ }
+ }
+
+ return result;
+ }
+
+ private Dictionary CollectSinglePosAdjustments(OpenTypeFont font)
+ {
+ var result = new Dictionary();
+
+ var singlePosLookup = FindFirstLookupOfType(font.GposTable, 1);
+ if (singlePosLookup == null) return result;
+
+ foreach (var subtableObj in singlePosLookup.SubTables)
+ {
+ var f1 = subtableObj as SinglePosSubTableFormat1;
+ if (f1 != null)
+ {
+ var glyphIds = f1.Coverage.GetCoveredGlyphs();
+ foreach (var glyphId in glyphIds)
+ {
+ result[glyphId] = new SinglePosValue
+ {
+ XPlacement = f1.Value.XPlacement,
+ YPlacement = f1.Value.YPlacement,
+ XAdvance = f1.Value.XAdvance,
+ YAdvance = f1.Value.YAdvance
+ };
+ }
+ continue;
+ }
+
+ var f2 = subtableObj as SinglePosSubTableFormat2;
+ if (f2 != null)
+ {
+ var glyphIds = f2.Coverage.GetCoveredGlyphs();
+ for (int i = 0; i < glyphIds.Length && i < f2.Values.Length; i++)
+ {
+ result[glyphIds[i]] = new SinglePosValue
+ {
+ XPlacement = f2.Values[i].XPlacement,
+ YPlacement = f2.Values[i].YPlacement,
+ XAdvance = f2.Values[i].XAdvance,
+ YAdvance = f2.Values[i].YAdvance
+ };
+ }
+ }
+ }
+
+ return result;
+ }
+
+ private Dictionary CollectMarkToBaseAttachments(
+ MarkToBaseSubTableFormat1 subtable)
+ {
+ var result = new Dictionary();
+
+ var markGlyphs = subtable.MarkCoverage.GetCoveredGlyphs();
+ var baseGlyphs = subtable.BaseCoverage.GetCoveredGlyphs();
+
+ int markLimit = markGlyphs.Length > 100 ? 100 : markGlyphs.Length;
+ int baseLimit = baseGlyphs.Length > 100 ? 100 : baseGlyphs.Length;
+
+ for (int m = 0; m < markLimit; m++)
+ {
+ ushort markGlyph = markGlyphs[m];
+
+ for (int b = 0; b < baseLimit; b++)
+ {
+ ushort baseGlyph = baseGlyphs[b];
+
+ AnchorTable markAnchor, baseAnchor;
+ if (subtable.TryGetAttachment(markGlyph, baseGlyph, out markAnchor, out baseAnchor))
+ {
+ var key = new GlyphPair(markGlyph, baseGlyph);
+ result[key] = new AnchorPointPair
+ {
+ MarkAnchorX = markAnchor.XCoordinate,
+ MarkAnchorY = markAnchor.YCoordinate,
+ BaseAnchorX = baseAnchor.XCoordinate,
+ BaseAnchorY = baseAnchor.YCoordinate
+ };
+ }
+ }
+ }
+
+ return result;
+ }
+
+ private List GetCoveragesFromSubtable(object subtable)
+ {
+ var coverages = new List();
+
+ var pp1 = subtable as PairPosSubTableFormat1;
+ if (pp1 != null)
+ {
+ coverages.Add(pp1.Coverage);
+ return coverages;
+ }
+
+ var sp1 = subtable as SinglePosSubTableFormat1;
+ if (sp1 != null)
+ {
+ coverages.Add(sp1.Coverage);
+ return coverages;
+ }
+
+ var sp2 = subtable as SinglePosSubTableFormat2;
+ if (sp2 != null)
+ {
+ coverages.Add(sp2.Coverage);
+ return coverages;
+ }
+
+ var mtb = subtable as MarkToBaseSubTableFormat1;
+ if (mtb != null)
+ {
+ coverages.Add(mtb.MarkCoverage);
+ coverages.Add(mtb.BaseCoverage);
+ return coverages;
+ }
+
+ return coverages;
+ }
+
+ #endregion
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Subsetting/BasicSubsettingTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Subsetting/BasicSubsettingTests.cs
index 2d599f36d..42348bde1 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Subsetting/BasicSubsettingTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Subsetting/BasicSubsettingTests.cs
@@ -39,7 +39,7 @@ public void Subset_Abc_RoundtripValidation()
// Act
var serializer = new OpenTypeFontSerializer(subsetFont);
var bytes = serializer.Serialize();
- var parsedFont = new OpenTypeFont(new FontsBinaryReader(new MemoryStream(bytes)), font.Format);
+ var parsedFont = new OpenTypeFont(bytes, font.Format);
// Save for inspection
SaveFont("subset_Roboto_abc.ttf", parsedFont);
@@ -90,7 +90,7 @@ public void Subset_Fiffig_WithFullValidation()
// Act
var serializer = new OpenTypeFontSerializer(subsetFont);
var bytes = serializer.Serialize();
- var parsedFont = new OpenTypeFont(new FontsBinaryReader(new MemoryStream(bytes)), font.Format);
+ var parsedFont = new OpenTypeFont(bytes, font.Format);
// Save for inspection
SaveFont("subset_Roboto_fiffig.ttf", parsedFont);
@@ -107,7 +107,7 @@ public void Subset_SingleChar_ShouldWork()
var serializer = new OpenTypeFontSerializer(subsetFont);
var bytes = serializer.Serialize();
- var parsedFont = new OpenTypeFont(new FontsBinaryReader(new MemoryStream(bytes)), font.Format);
+ var parsedFont = new OpenTypeFont(bytes, font.Format);
SaveFont("subset_Mulish_a.ttf", parsedFont);
@@ -125,7 +125,7 @@ public void Subset_MultipleChars_ShouldWork()
var serializer = new OpenTypeFontSerializer(subsetFont);
var bytes = serializer.Serialize();
- var parsedFont = new OpenTypeFont(new FontsBinaryReader(new MemoryStream(bytes)), font.Format);
+ var parsedFont = new OpenTypeFont(bytes, font.Format);
SaveFont("subset_Roboto_flygande_bäckasiner.ttf", parsedFont);
@@ -213,13 +213,20 @@ public void Subset_Ligatures_ShouldStillWork()
}
}
+ Debug.WriteLine("\n=== ORIGINAL FEATURES ===");
+ for (int i = 0; i < font.GsubTable.FeatureList.FeatureRecords.Count && i < 10; i++)
+ {
+ var feat = font.GsubTable.FeatureList.FeatureRecords[i];
+ Debug.WriteLine($"Feature[{i}]: '{feat.FeatureTag.Value}'");
+ }
+
// Create subset
Debug.WriteLine("\n=== CREATING SUBSET ===");
var subsetFont = font.CreateSubset("fiffigoffice");
var serializer = new OpenTypeFontSerializer(subsetFont);
var bytes = serializer.Serialize();
- var parsedFont = new OpenTypeFont(new FontsBinaryReader(new MemoryStream(bytes)), font.Format);
+ var parsedFont = new OpenTypeFont(bytes, font.Format);
SaveFont("subset_Roboto_ligatures_test.ttf", parsedFont);
@@ -280,6 +287,36 @@ public void Subset_Ligatures_ShouldStillWork()
}
}
+ Debug.WriteLine($"\n=== SCRIPTLIST & LANGSYS ===");
+ if (parsedFont.GsubTable.ScriptList != null)
+ {
+ foreach (var scriptRecord in parsedFont.GsubTable.ScriptList.ScriptRecords)
+ {
+ string scriptTag = scriptRecord.ScriptTag.Value;
+ Debug.WriteLine($"\nScript: '{scriptTag}'");
+
+ var scriptTable = scriptRecord.ScriptTable;
+
+ // Check DefaultLangSys
+ if (scriptTable.DefaultLangSys != null)
+ {
+ var defLang = scriptTable.DefaultLangSys;
+ Debug.WriteLine($" DefaultLangSys:");
+ Debug.WriteLine($" RequiredFeatureIndex: {defLang.RequiredFeatureIndex}");
+ Debug.WriteLine($" FeatureIndices: [{string.Join(", ", defLang.FeatureIndices.Select(i => i.ToString()).ToArray())}]");
+
+ // Show what features these indices point to
+ foreach (var featIdx in defLang.FeatureIndices)
+ {
+ if (featIdx < parsedFont.GsubTable.FeatureList.FeatureRecords.Count)
+ {
+ var feat = parsedFont.GsubTable.FeatureList.FeatureRecords[featIdx];
+ Debug.WriteLine($" Feature[{featIdx}]: '{feat.FeatureTag.Value}'");
+ }
+ }
+ }
+ }
+ }
FontTestHelper.AssertFontValid(parsedFont, FontValidationSeverity.Warning);
}
@@ -329,7 +366,7 @@ public void Subset_WithGposKerning_ShouldPreservePositioning()
var serializer = new OpenTypeFontSerializer(subsetFont);
var bytes = serializer.Serialize();
- var parsedFont = new OpenTypeFont(new FontsBinaryReader(new MemoryStream(bytes)), font.Format);
+ var parsedFont = new OpenTypeFont(bytes, font.Format);
SaveFont("subset_Roboto_with_gpos_kerning.ttf", parsedFont);
@@ -383,7 +420,7 @@ public void Subset_WithGposSingleAdjustment_ShouldPreserve()
// Act
var serializer = new OpenTypeFontSerializer(subsetFont);
var bytes = serializer.Serialize();
- var parsedFont = new OpenTypeFont(new FontsBinaryReader(new MemoryStream(bytes)), font.Format);
+ var parsedFont = new OpenTypeFont(bytes, font.Format);
// Save for inspection
SaveFont("subset_Roboto_with_gpos_singleadj.ttf", parsedFont);
@@ -427,7 +464,7 @@ public void Subset_WithGposMarkToBase_ShouldPreserveAccents()
// Act
var serializer = new OpenTypeFontSerializer(subsetFont);
var bytes = serializer.Serialize();
- var parsedFont = new OpenTypeFont(new FontsBinaryReader(new MemoryStream(bytes)), font.Format);
+ var parsedFont = new OpenTypeFont(bytes, font.Format);
// Save for inspection
SaveFont("subset_Roboto_with_gpos_accents.ttf", parsedFont);
@@ -478,7 +515,7 @@ public void Subset_CompleteGposTest_AllThreeLookupTypes()
// Act
var serializer = new OpenTypeFontSerializer(subsetFont);
var bytes = serializer.Serialize();
- var parsedFont = new OpenTypeFont(new FontsBinaryReader(new MemoryStream(bytes)), font.Format);
+ var parsedFont = new OpenTypeFont(bytes, font.Format);
// Save for inspection
SaveFont("subset_Roboto_complete_gpos_test.ttf", parsedFont);
diff --git a/src/EPPlus.Fonts.OpenType/FontTableReaderFactory.cs b/src/EPPlus.Fonts.OpenType/FontTableReaderFactory.cs
new file mode 100644
index 000000000..9bf3a08ec
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/FontTableReaderFactory.cs
@@ -0,0 +1,29 @@
+using System;
+using System.IO;
+
+namespace EPPlus.Fonts.OpenType
+{
+ internal class FontTableReaderFactory
+ {
+ public FontTableReaderFactory(byte[] fontBytes)
+ {
+ _fontBytes = fontBytes ?? throw new ArgumentNullException(nameof(fontBytes));
+ }
+
+ private readonly byte[] _fontBytes;
+
+ public int FontBytesLength => _fontBytes?.Length ?? 0;
+
+ public FontsBinaryReader CreateReader(long baseOffset = 0)
+ {
+ if (baseOffset == -1) baseOffset = 0;
+ // Validate and clamp baseOffset
+ if (baseOffset < 0 || baseOffset > _fontBytes.Length)
+ throw new ArgumentOutOfRangeException("baseOffset", "Offset is outside of the font buffer.");
+
+ var ms = new MemoryStream(_fontBytes);
+ ms.Position = baseOffset;
+ return new FontsBinaryReader(ms);
+ }
+ }
+}
diff --git a/src/EPPlus.Fonts.OpenType/OpenTypeFont.cs b/src/EPPlus.Fonts.OpenType/OpenTypeFont.cs
index 104f4cd1d..0198dc7bc 100644
--- a/src/EPPlus.Fonts.OpenType/OpenTypeFont.cs
+++ b/src/EPPlus.Fonts.OpenType/OpenTypeFont.cs
@@ -10,7 +10,6 @@ Date Author Change
*************************************************************************************************
10/07/2025 EPPlus Software AB EPPlus.Fonts.OpenType 1.0
*************************************************************************************************/
-using EPPlus.Fonts.OpenType.FontLocalization;
using EPPlus.Fonts.OpenType.FontValidation;
using EPPlus.Fonts.OpenType.Scanner;
using EPPlus.Fonts.OpenType.Subsetting;
@@ -31,7 +30,6 @@ Date Author Change
using System;
using System.Collections.Generic;
using System.Linq;
-using static System.Net.Mime.MediaTypeNames;
namespace EPPlus.Fonts.OpenType
{
@@ -41,8 +39,9 @@ namespace EPPlus.Fonts.OpenType
public class OpenTypeFont
{
internal TableCache _localTableCache;
+ internal TableLoaderCache _loaderCache;
internal TableLoaderSettings _tblSettings;
- private readonly FontsBinaryReader _reader;
+ private readonly byte[] _fontBytes;
protected Dictionary _tableRecords;
public FontFormat Format;
private readonly object _syncRoot = new object();
@@ -53,34 +52,37 @@ internal OpenTypeFont(FontFormat format)
Format = format;
_tableRecords = new Dictionary();
_localTableCache = new TableCache();
+ _loaderCache = new TableLoaderCache();
}
- internal OpenTypeFont(FontsBinaryReader reader, FontFormat format)
- : this(reader, -1, format)
+ internal OpenTypeFont(byte[] fontBytes, FontFormat format)
+ : this(fontBytes, -1, format)
{
}
- internal OpenTypeFont(FontsBinaryReader reader, long startOffset, FontFormat format)
+ internal OpenTypeFont(byte[] fontBytes, long startOffset, FontFormat format)
{
Format = format;
- _reader = reader;
+ _fontBytes = fontBytes;
+ var tableReaderFactory = new FontTableReaderFactory(fontBytes);
+ using var reader = tableReaderFactory.CreateReader(startOffset);
lock (_syncRoot)
{
if (startOffset > -1)
{
- _reader.BaseStream.Position = startOffset;
+ reader.BaseStream.Position = startOffset;
}
- Initialize(); // Reads SFNT header
- ReadTableRecords(); // Reads table directory
+ Initialize(reader); // Reads SFNT header
+ ReadTableRecords(reader); // Reads table directory
}
_localTableCache = new TableCache();
-
- _tblSettings = new TableLoaderSettings(_reader, _tableRecords, _localTableCache);
+ _loaderCache = new TableLoaderCache();
+ _tblSettings = new TableLoaderSettings(tableReaderFactory, _tableRecords, _localTableCache, _loaderCache);
//Ensure lazy-loading of individual tables via instanced table loaders.
_os2TableLoader = TableLoaders.GetOs2TableLoader(_tblSettings);
@@ -357,35 +359,35 @@ public GposTable GposTable
}
}
- private void Initialize()
+ private void Initialize(FontsBinaryReader reader)
{
- SfntVersion = _reader.ReadUInt32BigEndian();
+ SfntVersion = reader.ReadUInt32BigEndian();
// Number of tables.
- NumTables = _reader.ReadUInt16BigEndian();
+ NumTables = reader.ReadUInt16BigEndian();
// Maximum power of 2 less than or equal to numTables,
// times 16 ((2**floor(log2(numTables))) * 16,
// where “**” is an exponentiation operator).
- SearchRange = _reader.ReadUInt16BigEndian();
+ SearchRange = reader.ReadUInt16BigEndian();
// Log2 of the maximum power of 2 less than or equal to
// numTables (log2(searchRange/16), which is equal to
// floor(log2(numTables))).
- EntrySelector = _reader.ReadUInt16BigEndian();
+ EntrySelector = reader.ReadUInt16BigEndian();
// numTables times 16, minus searchRange
// ((numTables * 16) - searchRange).
- RangeShift = _reader.ReadUInt16BigEndian();
+ RangeShift = reader.ReadUInt16BigEndian();
}
- private void ReadTableRecords()
+ private void ReadTableRecords(FontsBinaryReader reader)
{
_tableRecords = new Dictionary();
for (var x = 0; x < NumTables; x++)
{
var record = new TableRecord
{
- Tag = new Tag(_reader),
- Checksum = _reader.ReadUInt32BigEndian(),
- Offset = _reader.ReadUInt32BigEndian(),
- Length = _reader.ReadUInt32BigEndian()
+ Tag = new Tag(reader),
+ Checksum = reader.ReadUInt32BigEndian(),
+ Offset = reader.ReadUInt32BigEndian(),
+ Length = reader.ReadUInt32BigEndian()
};
_tableRecords.Add(record.Tag.Value, record);
}
@@ -541,7 +543,7 @@ public OpenTypeFont CreateSubset_Old(IEnumerable usedChars)
GlyfTable.ResolveCompositeGlyphs(glyphIds);
// 3. Create new font instance
- var subsetFont = new OpenTypeFont(_reader, Format);
+ var subsetFont = new OpenTypeFont(_fontBytes, Format);
// 4. Copy and filter tables
subsetFont.AddOrReplaceTable(HeadTable.Clone());
@@ -596,20 +598,23 @@ internal long FileLength
{
get
{
- return _reader != null && _reader.BaseStream != null
- ? _reader.BaseStream.Length
- : 0L;
+ if(_tblSettings == null || _tblSettings.TableReaderFactory == null)
+ {
+ return 0L;
+ }
+ return _tblSettings.TableReaderFactory.FontBytesLength;
}
}
public byte[] GetTableData(string tag)
{
- if (_tableRecords.TryGetValue(tag, out var record))
+ if (_tableRecords.TryGetValue(tag, out var record) && _tblSettings != null && _tblSettings.TableReaderFactory != null)
{
- if(_reader != null && record.Offset > 0)
+ using var reader = _tblSettings.TableReaderFactory.CreateReader();
+ if (reader != null && record.Offset > 0)
{
- _reader.BaseStream.Position = record.Offset;
- return _reader.ReadBytes((int)record.Length);
+ reader.BaseStream.Position = record.Offset;
+ return reader.ReadBytes((int)record.Length);
}
}
var ctx = new FontSerializationContext(this);
@@ -650,17 +655,22 @@ public byte[] RawData
{
get
{
- if (_reader != null && _reader.BaseStream != null)
+ var reader = default(FontsBinaryReader);
+ if(_tblSettings != null && _tblSettings.TableReaderFactory != null)
+ {
+ reader = _tblSettings.TableReaderFactory.CreateReader();
+ }
+ if (reader != null && reader.BaseStream != null)
{
- long originalPosition = _reader.BaseStream.Position;
+ long originalPosition = reader.BaseStream.Position;
try
{
- _reader.BaseStream.Position = 0;
- return _reader.ReadBytes((int)_reader.BaseStream.Length);
+ reader.BaseStream.Position = 0;
+ return reader.ReadBytes((int)reader.BaseStream.Length);
}
finally
{
- _reader.BaseStream.Position = originalPosition;
+ reader.BaseStream.Position = originalPosition;
}
}
return null;
diff --git a/src/EPPlus.Fonts.OpenType/OpenTypeFontFactory.cs b/src/EPPlus.Fonts.OpenType/OpenTypeFontFactory.cs
index f71ce5004..6e1e3a729 100644
--- a/src/EPPlus.Fonts.OpenType/OpenTypeFontFactory.cs
+++ b/src/EPPlus.Fonts.OpenType/OpenTypeFontFactory.cs
@@ -23,8 +23,8 @@ public static OpenTypeFont CreateFromFace(FontFaceInfo face)
byte[] fontData = File.ReadAllBytes(face.FilePath);
var stream = new MemoryStream(fontData);
- var reader = new FontsBinaryReader(stream);
- reader.BaseStream.Position = face.OffsetInFile;
+ //var reader = new FontsBinaryReader(stream);
+ //reader.BaseStream.Position = face.OffsetInFile;
var format = face.OffsetInFile > 0
? FontFormat.Ttf
@@ -32,7 +32,7 @@ public static OpenTypeFont CreateFromFace(FontFaceInfo face)
? FontFormat.Otf
: FontFormat.Ttf;
- return new OpenTypeFont(reader, format);
+ return new OpenTypeFont(fontData, format);
}
}
}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/OpenTypeFontSerializer.cs b/src/EPPlus.Fonts.OpenType/OpenTypeFontSerializer.cs
index 21711fe8e..5c1e8a418 100644
--- a/src/EPPlus.Fonts.OpenType/OpenTypeFontSerializer.cs
+++ b/src/EPPlus.Fonts.OpenType/OpenTypeFontSerializer.cs
@@ -11,6 +11,7 @@ Date Author Change
10/07/2025 EPPlus Software AB EPPlus.Fonts.OpenType 1.0
*************************************************************************************************/
using System;
+using System.Collections.Generic;
using System.IO;
using System.Linq;
@@ -26,54 +27,80 @@ public OpenTypeFontSerializer(OpenTypeFont font)
_font = font ?? throw new ArgumentNullException(nameof(font));
}
+ // In OpenTypeFontSerializer class
+
public byte[] Serialize()
{
- using var stream = new MemoryStream();
- using var writer = new FontsBinaryWriter(stream);
+ using (var stream = new MemoryStream())
+ using (var writer = new FontsBinaryWriter(stream))
+ {
+ var sortedTags = _font.TableRecords.Keys.OrderBy(k => k).ToList();
+ int numTables = sortedTags.Count;
- var sortedRecords = _font.TableRecords
- .OrderBy(r => r.Key)
- .Select(r => r.Value)
- .ToList();
+ // 1. First pass: serialize all tables to get their actual bytes
+ var tableBytes = new Dictionary();
+ foreach (var tag in sortedTags)
+ {
+ byte[] data;
+ if (_font.PreprocessedPaddedTables != null &&
+ _font.PreprocessedPaddedTables.TryGetValue(tag, out var cachedBytes))
+ {
+ data = cachedBytes;
+ }
+ else
+ {
+ data = _font.GetTableData(tag);
+ // Pad to 4-byte boundary
+ int rawLen = data.Length;
+ int paddedLen = (rawLen + 3) & ~3;
+ if (paddedLen > rawLen)
+ {
+ Array.Resize(ref data, paddedLen);
+ }
+ }
+ tableBytes[tag] = data;
+ }
- int numTables = sortedRecords.Count;
+ // 2. Calculate correct offsets
+ // Header = 12 bytes, each table record = 16 bytes
+ uint currentOffset = (uint)(12 + numTables * 16);
- // 1. Write sfnt header
- WriteSfntHeader(writer, numTables);
+ var newRecords = new List();
+ foreach (var tag in sortedTags)
+ {
+ var data = tableBytes[tag];
+ var originalRecord = _font.TableRecords[tag];
- // 2. Write table directory
- foreach (var record in sortedRecords)
- {
- WriteTableRecord(writer, record);
- }
+ var newRecord = new TableRecord
+ {
+ Tag = new Tag(tag),
+ Checksum = originalRecord.Checksum, // Keep original checksum for now
+ Offset = currentOffset,
+ Length = originalRecord.Length
+ };
+ newRecords.Add(newRecord);
+
+ // Move to next table (already padded)
+ currentOffset += (uint)data.Length;
+ }
- // 3. Write tables (use preprocessed padded bytes if available)
- foreach (var record in sortedRecords)
- {
- var tag = record.Tag.Value;
+ // 3. Write sfnt header
+ WriteSfntHeader(writer, numTables);
- byte[] tableBytes;
- if (_font.PreprocessedPaddedTables != null &&
- _font.PreprocessedPaddedTables.TryGetValue(tag, out var cachedBytes))
+ // 4. Write table directory with CORRECT offsets
+ foreach (var record in newRecords)
{
- tableBytes = cachedBytes; // Use preprocessed padded bytes
+ WriteTableRecord(writer, record);
}
- else
+
+ // 5. Write table data
+ foreach (var tag in sortedTags)
{
- // Fallback: get raw data and pad
- tableBytes = _font.GetTableData(tag);
- int rawLen = tableBytes.Length;
- int paddedLen = (rawLen + 3) & ~3;
- if (paddedLen > rawLen)
- {
- Array.Resize(ref tableBytes, paddedLen);
- }
+ writer.Write(tableBytes[tag]);
}
- writer.Write(tableBytes);
+ return stream.ToArray();
}
-
- return stream.ToArray();
}
private void WriteSfntHeader(FontsBinaryWriter writer, int numTables)
@@ -105,4 +132,4 @@ private void WriteTableRecord(FontsBinaryWriter writer, TableRecord record)
}
}
-}
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/OpenTypeFonts.cs b/src/EPPlus.Fonts.OpenType/OpenTypeFonts.cs
index 3895552d2..94940a63a 100644
--- a/src/EPPlus.Fonts.OpenType/OpenTypeFonts.cs
+++ b/src/EPPlus.Fonts.OpenType/OpenTypeFonts.cs
@@ -13,6 +13,7 @@ Date Author Change
*************************************************************************************************/
using EPPlus.Fonts.OpenType.FontCache;
using EPPlus.Fonts.OpenType.Scanner;
+using EPPlus.Fonts.OpenType.Tables;
using EPPlus.Fonts.OpenType.Utils.Platform;
using System;
using System.Collections.Generic;
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/Features/FeatureListTable.cs b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/Features/FeatureListTable.cs
index d05cc08a9..9eb9c9bba 100644
--- a/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/Features/FeatureListTable.cs
+++ b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/Features/FeatureListTable.cs
@@ -10,8 +10,10 @@ Date Author Change
*************************************************************************************************
10/07/2025 EPPlus Software AB EPPlus.Fonts.OpenType 1.0
*************************************************************************************************/
-using System.Collections.Generic;
using EPPlus.Fonts.OpenType.Subsetting;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
namespace EPPlus.Fonts.OpenType.Tables.Common.Layout.Features
{
@@ -57,29 +59,49 @@ internal override void Serialize(FontsBinaryWriter writer)
///
/// Rewrites the feature list for a subset font.
///
- internal FeatureListTable Rewrite(FontSubsettingContext context, Dictionary lookupMap)
+ internal FeatureRewriteResult Rewrite(FontSubsettingContext context, Dictionary lookupMap)
{
+ var newFeatures = new List();
+ var oldToNewFeatureMap = new Dictionary();
- var newList = new FeatureListTable();
- newList.FeatureRecords = new List();
-
- for (int i = 0; i < this.FeatureRecords.Count; i++)
+ for (int oldIndex = 0; oldIndex < this.FeatureRecords.Count; oldIndex++)
{
- var oldRecord = this.FeatureRecords[i];
+ var feature = this.FeatureRecords[oldIndex];
- // Skriv om featuren med den nya lookupmappen
- var rewrittenRecord = oldRecord.Rewrite(context, lookupMap);
+ if (oldIndex >= 5 && oldIndex <= 7) // Debug 'liga' features
+ {
+ Debug.WriteLine($"\n=== Processing feature[{oldIndex}]: '{feature.FeatureTag.Value}' ===");
+ if (feature.FeatureTable != null)
+ {
+ Debug.WriteLine($" Original lookups: [{string.Join(", ", feature.FeatureTable.LookupListIndices.Select(i => i.ToString()).ToArray())}]");
+ }
+ }
- // ✅ FIX: Kolla om RECORDEN är null (inte featuren)
- if (rewrittenRecord != null &&
- rewrittenRecord.FeatureTable != null &&
- rewrittenRecord.FeatureTable.LookupListIndices != null &&
- rewrittenRecord.FeatureTable.LookupListIndices.Length > 0)
+ var rewrittenFeature = feature.Rewrite(context, lookupMap);
+ if (oldIndex >= 5 && oldIndex <= 7)
{
- newList.FeatureRecords.Add(rewrittenRecord);
+ if (rewrittenFeature != null && rewrittenFeature.FeatureTable != null)
+ {
+ Debug.WriteLine($" Rewritten lookups: [{string.Join(", ", rewrittenFeature.FeatureTable.LookupListIndices.Select(i => i.ToString()).ToArray())}]");
+ }
+ else
+ {
+ Debug.WriteLine($" ❌ REMOVED (no valid lookups remain)");
+ }
+ }
+ if (rewrittenFeature != null)
+ {
+ int newIndex = newFeatures.Count;
+ oldToNewFeatureMap[oldIndex] = newIndex;
+ newFeatures.Add(rewrittenFeature);
}
}
- return newList;
+
+ return new FeatureRewriteResult
+ {
+ NewFeatureList = new FeatureListTable { FeatureRecords = newFeatures },
+ OldToNewIndexMap = oldToNewFeatureMap
+ };
}
}
}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/Features/FeatureRewriteResult.cs b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/Features/FeatureRewriteResult.cs
new file mode 100644
index 000000000..26b7508f4
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/Features/FeatureRewriteResult.cs
@@ -0,0 +1,22 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 10/07/2025 EPPlus Software AB EPPlus.Fonts.OpenType 1.0
+ *************************************************************************************************/
+using System.Collections.Generic;
+
+namespace EPPlus.Fonts.OpenType.Tables.Common.Layout.Features
+{
+ internal class FeatureRewriteResult
+ {
+ public FeatureListTable NewFeatureList { get; set; }
+ public Dictionary OldToNewIndexMap { get; set; }
+ }
+}
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/Scripts/ScriptListTable.cs b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/Scripts/ScriptListTable.cs
index 418328d9d..8c95b8bf7 100644
--- a/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/Scripts/ScriptListTable.cs
+++ b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/Scripts/ScriptListTable.cs
@@ -10,6 +10,7 @@ Date Author Change
*************************************************************************************************
10/07/2025 EPPlus Software AB EPPlus.Fonts.OpenType 1.0
*************************************************************************************************/
+using EPPlus.Fonts.OpenType.Subsetting;
using EPPlus.Fonts.OpenType.Tables.Gsub.Data;
using System.Collections.Generic;
using System.IO;
@@ -75,80 +76,95 @@ internal override void Serialize(FontsBinaryWriter writer)
}
}
- internal ScriptListTable Rewrite(Subsetting.FontSubsettingContext context)
+ internal ScriptListTable Rewrite(FontSubsettingContext context, Dictionary featureIndexMap)
{
- var newList = new ScriptListTable();
+ var newScriptList = new ScriptListTable();
- foreach (var oldRecord in this.ScriptRecords)
+ foreach (var scriptRecord in this.ScriptRecords)
{
- var newRecord = new ScriptRecord();
- newRecord.ScriptTag = oldRecord.ScriptTag;
-
- if (oldRecord.ScriptTable != null)
+ var newScriptRecord = new ScriptRecord
{
- var oldTable = oldRecord.ScriptTable;
- var newTable = new ScriptTable();
+ ScriptTag = scriptRecord.ScriptTag,
+ ScriptTable = RewriteScriptTable(scriptRecord.ScriptTable, featureIndexMap)
+ };
- // Copy DefaultLangSys
- if (oldTable.DefaultLangSys != null)
- {
- var oldLang = oldTable.DefaultLangSys;
- var newLang = new LangSysTable();
- newLang.LookupOrder = oldLang.LookupOrder;
- newLang.RequiredFeatureIndex = oldLang.RequiredFeatureIndex;
- newLang.FeatureIndexCount = oldLang.FeatureIndexCount;
-
- if (oldLang.FeatureIndices != null)
- {
- var newIndices = new ushort[oldLang.FeatureIndices.Length];
- for (int i = 0; i < oldLang.FeatureIndices.Length; i++)
- {
- newIndices[i] = oldLang.FeatureIndices[i];
- }
- newLang.FeatureIndices = newIndices;
- }
- newTable.DefaultLangSys = newLang;
- }
-
- // Copy LangSysRecords
- if (oldTable.LangSysRecords != null)
+ newScriptList.ScriptRecords.Add(newScriptRecord);
+ }
+
+ return newScriptList;
+ }
+
+ ///
+ /// Rewrites a ScriptTable by remapping feature indices.
+ ///
+ private ScriptTable RewriteScriptTable(ScriptTable original, Dictionary featureIndexMap)
+ {
+ var newScriptTable = new ScriptTable
+ {
+ DefaultLangSysOffset = original.DefaultLangSysOffset
+ };
+
+ // Rewrite DefaultLangSys
+ if (original.DefaultLangSys != null)
+ {
+ newScriptTable.DefaultLangSys = RewriteLangSys(original.DefaultLangSys, featureIndexMap);
+ }
+
+ // Rewrite LangSysRecords
+ foreach (var langSysRecord in original.LangSysRecords)
+ {
+ var newLangSys = RewriteLangSys(langSysRecord.LangSysTable, featureIndexMap);
+ if (newLangSys != null && newLangSys.FeatureIndices.Length > 0)
+ {
+ newScriptTable.LangSysRecords.Add(new LangSysRecord
{
- newTable.LangSysRecords = new List();
- foreach (var oldLangRecord in oldTable.LangSysRecords)
- {
- var newLangRecord = new LangSysRecord();
- newLangRecord.LangSysTag = oldLangRecord.LangSysTag;
-
- if (oldLangRecord.LangSysTable != null)
- {
- var oldL = oldLangRecord.LangSysTable;
- var newL = new LangSysTable();
- newL.LookupOrder = oldL.LookupOrder;
- newL.RequiredFeatureIndex = oldL.RequiredFeatureIndex;
- newL.FeatureIndexCount = oldL.FeatureIndexCount;
-
- if (oldL.FeatureIndices != null)
- {
- var newIndices = new ushort[oldL.FeatureIndices.Length];
- for (int j = 0; j < oldL.FeatureIndices.Length; j++)
- {
- newIndices[j] = oldL.FeatureIndices[j];
- }
- newL.FeatureIndices = newIndices;
- }
- newLangRecord.LangSysTable = newL;
- }
- newTable.LangSysRecords.Add(newLangRecord);
- }
- }
-
- newRecord.ScriptTable = newTable;
+ LangSysTag = langSysRecord.LangSysTag,
+ LangSysTable = newLangSys
+ });
}
+ }
- newList.ScriptRecords.Add(newRecord);
+ return newScriptTable;
+ }
+
+ ///
+ /// Rewrites a LangSysTable by remapping feature indices.
+ ///
+ private LangSysTable RewriteLangSys(LangSysTable original, Dictionary featureIndexMap)
+ {
+ if (original == null)
+ return null;
+
+ var newFeatureIndices = new List();
+
+ // Remap each feature index
+ foreach (var oldIndex in original.FeatureIndices)
+ {
+ if (featureIndexMap.TryGetValue(oldIndex, out int newIndex))
+ {
+ newFeatureIndices.Add((ushort)newIndex);
+ }
+ // Else: feature was removed, skip it
+ }
+
+ // Handle RequiredFeatureIndex
+ ushort newRequiredFeatureIndex = 0xFFFF; // Default: no required feature
+ if (original.RequiredFeatureIndex != 0xFFFF)
+ {
+ if (featureIndexMap.TryGetValue(original.RequiredFeatureIndex, out int mappedRequired))
+ {
+ newRequiredFeatureIndex = (ushort)mappedRequired;
+ }
+ // Else: required feature was removed, set to 0xFFFF
}
- return newList;
+ return new LangSysTable
+ {
+ LookupOrder = original.LookupOrder,
+ RequiredFeatureIndex = newRequiredFeatureIndex,
+ FeatureIndexCount = (ushort)newFeatureIndices.Count,
+ FeatureIndices = newFeatureIndices.ToArray()
+ };
}
}
}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Gpos/GposTable.cs b/src/EPPlus.Fonts.OpenType/Tables/Gpos/GposTable.cs
index a3bc13712..efca83840 100644
--- a/src/EPPlus.Fonts.OpenType/Tables/Gpos/GposTable.cs
+++ b/src/EPPlus.Fonts.OpenType/Tables/Gpos/GposTable.cs
@@ -124,19 +124,39 @@ internal GposTable Rewrite(FontSubsettingContext context)
if (processor == null)
return null;
- // Rewrite LookupList
- var newLookupList = RewriteLookupList(context, processor);
- if (newLookupList == null || newLookupList.Lookups.Count == 0)
- return null; // No positioning data remains
+ // 1. Rewrite LookupList first - creates lookup index mapping
+ LookupRewriteResult lookupResult = null;
+ if (this.LookupList != null)
+ {
+ lookupResult = RewriteLookupList(context, processor);
+ if (lookupResult == null || lookupResult.NewLookupList == null || lookupResult.NewLookupList.Lookups.Count == 0)
+ return null; // No positioning data remains
+ }
+
+ // 2. Rewrite FeatureList - pass lookup index mapping, get feature index mapping back
+ FeatureRewriteResult featureResult = null;
+ if (this.FeatureList != null && lookupResult != null)
+ {
+ featureResult = this.FeatureList.Rewrite(context, lookupResult.OldToNewIndexMap);
+ if (featureResult == null || featureResult.NewFeatureList == null || featureResult.NewFeatureList.FeatureRecords.Count == 0)
+ return null; // No features remain
+ }
+
+ // 3. Rewrite ScriptList - pass feature index mapping
+ ScriptListTable newScriptList = null;
+ if (this.ScriptList != null && featureResult != null)
+ {
+ newScriptList = this.ScriptList.Rewrite(context, featureResult.OldToNewIndexMap);
+ }
// Create new GPOS table
var newGpos = new GposTable
{
MajorVersion = this.MajorVersion,
MinorVersion = this.MinorVersion,
- ScriptList = this.ScriptList, // Keep all scripts
- FeatureList = this.FeatureList, // Keep all features
- LookupList = newLookupList
+ ScriptList = newScriptList,
+ FeatureList = featureResult.NewFeatureList,
+ LookupList = lookupResult.NewLookupList
};
return newGpos;
@@ -145,18 +165,23 @@ internal GposTable Rewrite(FontSubsettingContext context)
///
/// Rewrites the LookupList by processing each lookup through its handler.
///
- private LookupListTable RewriteLookupList(FontSubsettingContext context, GposSubsetProcessor processor)
+ private LookupRewriteResult RewriteLookupList(FontSubsettingContext context, GposSubsetProcessor processor)
{
if (this.LookupList == null)
return null;
var newLookups = new List();
+ var oldToNewIndexMap = new Dictionary();
- foreach (var lookup in this.LookupList.Lookups)
+ for (int oldIndex = 0; oldIndex < this.LookupList.Lookups.Count; oldIndex++)
{
+ var lookup = this.LookupList.Lookups[oldIndex];
var rewrittenLookup = processor.RewriteLookup(context, lookup);
+
if (rewrittenLookup != null && rewrittenLookup.SubTables.Count > 0)
{
+ int newIndex = newLookups.Count;
+ oldToNewIndexMap[oldIndex] = newIndex;
newLookups.Add(rewrittenLookup);
}
}
@@ -164,9 +189,10 @@ private LookupListTable RewriteLookupList(FontSubsettingContext context, GposSub
if (newLookups.Count == 0)
return null;
- return new LookupListTable
+ return new LookupRewriteResult
{
- Lookups = newLookups
+ NewLookupList = new LookupListTable { Lookups = newLookups },
+ OldToNewIndexMap = oldToNewIndexMap
};
}
}
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Gsub/GsubTable.cs b/src/EPPlus.Fonts.OpenType/Tables/Gsub/GsubTable.cs
index 02964ce4d..a7f29f689 100644
--- a/src/EPPlus.Fonts.OpenType/Tables/Gsub/GsubTable.cs
+++ b/src/EPPlus.Fonts.OpenType/Tables/Gsub/GsubTable.cs
@@ -16,7 +16,9 @@ Date Author Change
using EPPlus.Fonts.OpenType.Tables.Common.Layout.Scripts;
using EPPlus.Fonts.OpenType.Utils;
using System;
+using System.Diagnostics;
using System.IO;
+using System.Linq;
namespace EPPlus.Fonts.OpenType.Tables.Gsub
{
@@ -107,27 +109,59 @@ public GsubTable Rewrite(FontSubsettingContext context)
newGsub.MajorVersion = this.MajorVersion;
newGsub.MinorVersion = this.MinorVersion;
- // 1. Skriv om Lookups först - detta skapar den nya listan OCH kartan över index-ändringar
+ // 1. Rewrite Lookups first - creates lookup index mapping
LookupRewriteResult lookupResult = null;
if (this.LookupList != null)
{
lookupResult = this.LookupList.Rewrite(context);
+ if (lookupResult == null || lookupResult.NewLookupList == null || lookupResult.NewLookupList.Lookups.Count == 0)
+ {
+ // No lookups remain - return null or minimal table
+ return null;
+ }
newGsub.LookupList = lookupResult.NewLookupList;
}
- // 2. Skriv om FeatureList - skicka med kartan (OldToNewIndexMap)
+ // 2. Rewrite FeatureList - pass lookup index mapping, get feature index mapping back
+ FeatureRewriteResult featureResult = null;
if (this.FeatureList != null && lookupResult != null)
{
- // Här behöver Rewrite-metoden ta emot kartan för att kunna peka om indexen korrekt
- newGsub.FeatureList = this.FeatureList.Rewrite(context, lookupResult.OldToNewIndexMap);
+ featureResult = this.FeatureList.Rewrite(context, lookupResult.OldToNewIndexMap);
+ if (featureResult != null)
+ {
+ Debug.WriteLine("\n=== FEATURE INDEX MAPPING ===");
+ Debug.WriteLine($"Original features: {this.FeatureList.FeatureRecords.Count}");
+ Debug.WriteLine($"New features: {featureResult.NewFeatureList.FeatureRecords.Count}");
+ Debug.WriteLine($"Mapping entries: {featureResult.OldToNewIndexMap.Count}");
+
+ Debug.WriteLine("\nMapping details:");
+ foreach (var kvp in featureResult.OldToNewIndexMap.OrderBy(k => k.Key))
+ {
+ var oldFeature = this.FeatureList.FeatureRecords[kvp.Key];
+ var newFeature = featureResult.NewFeatureList.FeatureRecords[kvp.Value];
+ Debug.WriteLine($" Old[{kvp.Key}] '{oldFeature.FeatureTag.Value}' → New[{kvp.Value}] '{newFeature.FeatureTag.Value}'");
+ }
+
+ Debug.WriteLine("\nOriginal script DFLT had features:");
+ var origDflt = this.ScriptList.ScriptRecords.FirstOrDefault(s => s.ScriptTag.Value == "DFLT");
+ if (origDflt?.ScriptTable?.DefaultLangSys != null)
+ {
+ var indices = string.Join(", ", origDflt.ScriptTable.DefaultLangSys.FeatureIndices.Select(i => i.ToString()).ToArray());
+ Debug.WriteLine($" [{indices}]");
+ }
+ }
+ if (featureResult == null || featureResult.NewFeatureList == null || featureResult.NewFeatureList.FeatureRecords.Count == 0)
+ {
+ // No features remain
+ return null;
+ }
+ newGsub.FeatureList = featureResult.NewFeatureList;
}
- // 3. Skriv om ScriptList
- if (this.ScriptList != null)
+ // 3. Rewrite ScriptList - pass feature index mapping
+ if (this.ScriptList != null && featureResult != null)
{
- // ScriptList pekar på Feature-index.
- // Om du har tagit bort features i steg 2 behöver du en liknande karta här!
- newGsub.ScriptList = this.ScriptList.Rewrite(context);
+ newGsub.ScriptList = this.ScriptList.Rewrite(context, featureResult.OldToNewIndexMap);
}
return newGsub;
diff --git a/src/EPPlus.Fonts.OpenType/Tables/TableCache.cs b/src/EPPlus.Fonts.OpenType/Tables/TableCache.cs
index 7c539bf02..a6e8e89dc 100644
--- a/src/EPPlus.Fonts.OpenType/Tables/TableCache.cs
+++ b/src/EPPlus.Fonts.OpenType/Tables/TableCache.cs
@@ -14,39 +14,105 @@ Date Author Change
namespace EPPlus.Fonts.OpenType.Tables
{
+ using System.Threading;
+
internal class TableCache
{
- private Dictionary _cachedTables = new Dictionary();
+ private readonly Dictionary _cachedTables = new Dictionary();
+ private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();
+
+ public bool TryGet(string key, out object value)
+ {
+ _lock.EnterReadLock();
+ try
+ {
+ return _cachedTables.TryGetValue(key, out value);
+ }
+ finally
+ {
+ _lock.ExitReadLock();
+ }
+ }
public object Get(string key)
{
- return _cachedTables[key];
+ _lock.EnterReadLock();
+ try
+ {
+ return _cachedTables[key];
+ }
+ finally
+ {
+ _lock.ExitReadLock();
+ }
}
public bool Contains(string key)
{
- return _cachedTables.ContainsKey(key);
+ _lock.EnterReadLock();
+ try
+ {
+ return _cachedTables.ContainsKey(key);
+ }
+ finally
+ {
+ _lock.ExitReadLock();
+ }
}
public void Add(string key, object val)
{
- _cachedTables.Add(key, val);
+ _lock.EnterWriteLock();
+ try
+ {
+ _cachedTables.Add(key, val);
+ }
+ finally
+ {
+ _lock.ExitWriteLock();
+ }
}
public void AddOrReplace(string key, object val)
{
- if (_cachedTables.ContainsKey(key))
+ _lock.EnterWriteLock();
+ try
+ {
+ _cachedTables[key] = val; // Enklare än ContainsKey + Remove
+ }
+ finally
{
- _cachedTables.Remove(key);
+ _lock.ExitWriteLock();
}
- _cachedTables[key] = val;
}
public void Clear()
{
- _cachedTables.Clear();
+ _lock.EnterWriteLock();
+ try
+ {
+ _cachedTables.Clear();
+ }
+ finally
+ {
+ _lock.ExitWriteLock();
+ }
}
- public int Count => _cachedTables.Keys.Count;
+ public int Count
+ {
+ get
+ {
+ _lock.EnterReadLock();
+ try
+ {
+ return _cachedTables.Count;
+ }
+ finally
+ {
+ _lock.ExitReadLock();
+ }
+ }
+ }
}
}
diff --git a/src/EPPlus.Fonts.OpenType/Tables/TableLoader.cs b/src/EPPlus.Fonts.OpenType/Tables/TableLoader.cs
index cfdbcda93..aa7588178 100644
--- a/src/EPPlus.Fonts.OpenType/Tables/TableLoader.cs
+++ b/src/EPPlus.Fonts.OpenType/Tables/TableLoader.cs
@@ -18,11 +18,11 @@ Date Author Change
namespace EPPlus.Fonts.OpenType.Tables
{
internal abstract class TableLoader
- where T : FontTableBase
+ where T : FontTableBase
{
public TableLoader(TableLoaderSettings tblSettings, string tableName)
{
- _reader = tblSettings._readerRef;
+ _reader = tblSettings.TableReaderFactory.CreateReader();
if (tblSettings._tableRecordsRef.ContainsKey(tableName))
{
_offset = tblSettings._tableRecordsRef[tableName].Offset;
@@ -31,6 +31,7 @@ public TableLoader(TableLoaderSettings tblSettings, string tableName)
_tables = tblSettings._tableRecordsRef;
_tableName = tableName;
tableCache = tblSettings._tblCacheRef;
+ _fontLock = tblSettings._loaderCacheRef.SyncLock; // <-- Add this
}
protected FontsBinaryReader _reader;
@@ -39,12 +40,11 @@ public TableLoader(TableLoaderSettings tblSettings, string tableName)
protected readonly uint _length;
protected Dictionary _tables;
internal TableCache tableCache;
+ private readonly object _fontLock; // <-- Add this
protected abstract T LoadInternal();
- // ✅ Instance lock for this specific table loader
private readonly object _instanceLock = new object();
-
private bool _isLoading;
private bool _isLoaded;
@@ -53,9 +53,10 @@ public T Load(bool useCache = true)
// First: Check cache with instance lock (fast path)
lock (_instanceLock)
{
- if (_isLoaded && tableCache != null && tableCache.Contains(_tableName) && useCache)
+ object cached;
+ if (_isLoaded && tableCache != null && tableCache.TryGet(_tableName, out cached) && useCache)
{
- return tableCache.Get(_tableName) as T;
+ return cached as T; // ✅ Atomisk operation!
}
while (_isLoading && !_isLoaded)
@@ -63,9 +64,9 @@ public T Load(bool useCache = true)
Monitor.Wait(_instanceLock);
}
- if (_isLoaded && tableCache != null)
+ if (_isLoaded && tableCache != null && tableCache.TryGet(_tableName, out cached) && useCache)
{
- return tableCache.Get(_tableName) as T;
+ return cached as T; // ✅ Atomisk operation!
}
_isLoading = true;
@@ -73,26 +74,25 @@ public T Load(bool useCache = true)
T t;
- // Second: Load table with reader lock
- lock (_reader)
+ // Second: Load table with font-level lock (protects ALL reader access for this font)
+ lock (_fontLock)
{
- // ✅ CRITICAL: Save and restore stream position!
- long savedPosition = _reader.BaseStream.Position;
-
- try
- {
- // Seek to table start
- _reader.BaseStream.Position = _offset;
-
- // Load the table
- t = LoadInternal();
- }
- finally
+ // ✅ FIX: Triple-check med TryGet
+ object cached;
+ if (tableCache != null && tableCache.TryGet(_tableName, out cached) && useCache)
{
- // ✅ RESTORE position after loading
- // This prevents interfering with other loaders
- _reader.BaseStream.Position = savedPosition;
+ lock (_instanceLock)
+ {
+ _isLoaded = true;
+ _isLoading = false;
+ Monitor.PulseAll(_instanceLock);
+ }
+ return cached as T; // ✅ Atomisk operation!
}
+
+ // Now safe to read - no other thread can access this font's reader
+ _reader.BaseStream.Position = _offset;
+ t = LoadInternal();
}
// Third: Update cache
diff --git a/src/EPPlus.Fonts.OpenType/Tables/TableLoaderCache.cs b/src/EPPlus.Fonts.OpenType/Tables/TableLoaderCache.cs
new file mode 100644
index 000000000..032eabd0f
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/Tables/TableLoaderCache.cs
@@ -0,0 +1,53 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/14/2026 EPPlus Software AB Loader cache for thread safety
+ *************************************************************************************************/
+using EPPlus.Fonts.OpenType.Tables.Cmap;
+using EPPlus.Fonts.OpenType.Tables.Glyph;
+using EPPlus.Fonts.OpenType.Tables.Gpos;
+using EPPlus.Fonts.OpenType.Tables.Gsub;
+using EPPlus.Fonts.OpenType.Tables.Head;
+using EPPlus.Fonts.OpenType.Tables.Hhea;
+using EPPlus.Fonts.OpenType.Tables.Hmtx;
+using EPPlus.Fonts.OpenType.Tables.Kern;
+using EPPlus.Fonts.OpenType.Tables.Loca;
+using EPPlus.Fonts.OpenType.Tables.Maxp;
+using EPPlus.Fonts.OpenType.Tables.Name;
+using EPPlus.Fonts.OpenType.Tables.Os2;
+using EPPlus.Fonts.OpenType.Tables.Post;
+
+namespace EPPlus.Fonts.OpenType.Tables
+{
+ ///
+ /// Cache for TableLoader instances to ensure thread-safe access.
+ /// Each OpenTypeFont instance has its own loader cache.
+ ///
+ internal class TableLoaderCache
+ {
+ private readonly object _lock = new object();
+
+ public LocaTableLoader LocaLoader;
+ public HeadTableLoader HeadLoader;
+ public CmapTableLoader CmapLoader;
+ public GlyfTableLoader GlyfLoader;
+ public Os2TableLoader Os2Loader;
+ public HheaTableLoader HheaLoader;
+ public MaxpTableLoader MaxpLoader;
+ public HmtxTableLoader HmtxLoader;
+ public NameTableLoader NameLoader;
+ public KernTableLoader KernLoader;
+ public PostTableLoader PostLoader;
+ public GsubTableLoader GsubLoader;
+ public GposTableLoader GposLoader;
+
+ internal object SyncLock { get { return _lock; } }
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/Tables/TableLoaderSettings.cs b/src/EPPlus.Fonts.OpenType/Tables/TableLoaderSettings.cs
index 28ba97277..6376aa6e1 100644
--- a/src/EPPlus.Fonts.OpenType/Tables/TableLoaderSettings.cs
+++ b/src/EPPlus.Fonts.OpenType/Tables/TableLoaderSettings.cs
@@ -9,25 +9,30 @@ This software is licensed under PolyForm Noncommercial License 1.0.0
Date Author Change
*************************************************************************************************
10/07/2025 EPPlus Software AB EPPlus.Fonts.OpenType 1.0
+ 01/14/2026 EPPlus Software AB Added loader cache reference
*************************************************************************************************/
-using System;
using System.Collections.Generic;
-using System.Linq;
-using System.Text;
namespace EPPlus.Fonts.OpenType.Tables
{
internal class TableLoaderSettings
{
- internal FontsBinaryReader _readerRef { get; private set; }
internal Dictionary _tableRecordsRef { get; private set; }
internal TableCache _tblCacheRef { get; private set; }
+ internal TableLoaderCache _loaderCacheRef { get; private set; }
- internal TableLoaderSettings(FontsBinaryReader reader, Dictionary records, TableCache tblCache)
+ internal FontTableReaderFactory TableReaderFactory { get; private set; }
+
+ internal TableLoaderSettings(
+ FontTableReaderFactory tableReaderFactory,
+ Dictionary records,
+ TableCache tblCache,
+ TableLoaderCache loaderCache)
{
- _readerRef = reader;
+ TableReaderFactory = tableReaderFactory;
_tableRecordsRef = records;
_tblCacheRef = tblCache;
+ _loaderCacheRef = loaderCache;
}
}
-}
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/Tables/TableLoaders.cs b/src/EPPlus.Fonts.OpenType/Tables/TableLoaders.cs
index 8ed582589..bf796e540 100644
--- a/src/EPPlus.Fonts.OpenType/Tables/TableLoaders.cs
+++ b/src/EPPlus.Fonts.OpenType/Tables/TableLoaders.cs
@@ -9,6 +9,7 @@ This software is licensed under PolyForm Noncommercial License 1.0.0
Date Author Change
*************************************************************************************************
10/07/2025 EPPlus Software AB EPPlus.Fonts.OpenType 1.0
+ 01/14/2026 EPPlus Software AB Cache loader instances for thread safety
*************************************************************************************************/
using EPPlus.Fonts.OpenType.Tables.Cmap;
using EPPlus.Fonts.OpenType.Tables.Glyph;
@@ -23,8 +24,6 @@ Date Author Change
using EPPlus.Fonts.OpenType.Tables.Name;
using EPPlus.Fonts.OpenType.Tables.Os2;
using EPPlus.Fonts.OpenType.Tables.Post;
-using System;
-using System.Collections.Generic;
namespace EPPlus.Fonts.OpenType.Tables
{
@@ -32,67 +31,171 @@ internal static class TableLoaders
{
public static LocaTableLoader GetLocaTableLoader(TableLoaderSettings settings)
{
- return new LocaTableLoader(settings);
+ var cache = settings._loaderCacheRef;
+ lock (cache.SyncLock)
+ {
+ if (cache.LocaLoader == null)
+ {
+ cache.LocaLoader = new LocaTableLoader(settings);
+ }
+ return cache.LocaLoader;
+ }
}
public static HeadTableLoader GetHeadTableLoader(TableLoaderSettings settings)
{
- return new HeadTableLoader(settings);
+ var cache = settings._loaderCacheRef;
+ lock (cache.SyncLock)
+ {
+ if (cache.HeadLoader == null)
+ {
+ cache.HeadLoader = new HeadTableLoader(settings);
+ }
+ return cache.HeadLoader;
+ }
}
public static CmapTableLoader GetCmapTableLoader(TableLoaderSettings settings)
{
- return new CmapTableLoader(settings);
+ var cache = settings._loaderCacheRef;
+ lock (cache.SyncLock)
+ {
+ if (cache.CmapLoader == null)
+ {
+ cache.CmapLoader = new CmapTableLoader(settings);
+ }
+ return cache.CmapLoader;
+ }
}
public static GlyfTableLoader GetGlyfTableLoader(TableLoaderSettings settings)
{
- return new GlyfTableLoader(settings);
+ var cache = settings._loaderCacheRef;
+ lock (cache.SyncLock)
+ {
+ if (cache.GlyfLoader == null)
+ {
+ cache.GlyfLoader = new GlyfTableLoader(settings);
+ }
+ return cache.GlyfLoader;
+ }
}
public static Os2TableLoader GetOs2TableLoader(TableLoaderSettings settings)
{
- return new Os2TableLoader(settings);
+ var cache = settings._loaderCacheRef;
+ lock (cache.SyncLock)
+ {
+ if (cache.Os2Loader == null)
+ {
+ cache.Os2Loader = new Os2TableLoader(settings);
+ }
+ return cache.Os2Loader;
+ }
}
public static HheaTableLoader GetHheaTableLoader(TableLoaderSettings settings)
{
- return new HheaTableLoader(settings);
+ var cache = settings._loaderCacheRef;
+ lock (cache.SyncLock)
+ {
+ if (cache.HheaLoader == null)
+ {
+ cache.HheaLoader = new HheaTableLoader(settings);
+ }
+ return cache.HheaLoader;
+ }
}
public static MaxpTableLoader GetMaxpTableLoader(TableLoaderSettings settings)
{
- return new MaxpTableLoader(settings);
+ var cache = settings._loaderCacheRef;
+ lock (cache.SyncLock)
+ {
+ if (cache.MaxpLoader == null)
+ {
+ cache.MaxpLoader = new MaxpTableLoader(settings);
+ }
+ return cache.MaxpLoader;
+ }
}
public static HmtxTableLoader GetHmtxTableLoader(TableLoaderSettings settings)
{
- return new HmtxTableLoader(settings);
+ var cache = settings._loaderCacheRef;
+ lock (cache.SyncLock)
+ {
+ if (cache.HmtxLoader == null)
+ {
+ cache.HmtxLoader = new HmtxTableLoader(settings);
+ }
+ return cache.HmtxLoader;
+ }
}
public static NameTableLoader GetNameTableLoader(TableLoaderSettings settings)
{
- return new NameTableLoader(settings);
+ var cache = settings._loaderCacheRef;
+ lock (cache.SyncLock)
+ {
+ if (cache.NameLoader == null)
+ {
+ cache.NameLoader = new NameTableLoader(settings);
+ }
+ return cache.NameLoader;
+ }
}
public static KernTableLoader GetKernTableLoader(TableLoaderSettings settings)
{
- return new KernTableLoader(settings);
+ var cache = settings._loaderCacheRef;
+ lock (cache.SyncLock)
+ {
+ if (cache.KernLoader == null)
+ {
+ cache.KernLoader = new KernTableLoader(settings);
+ }
+ return cache.KernLoader;
+ }
}
public static PostTableLoader GetPostTableLoader(TableLoaderSettings settings)
{
- return new PostTableLoader(settings);
+ var cache = settings._loaderCacheRef;
+ lock (cache.SyncLock)
+ {
+ if (cache.PostLoader == null)
+ {
+ cache.PostLoader = new PostTableLoader(settings);
+ }
+ return cache.PostLoader;
+ }
}
public static GsubTableLoader GetGsubTableLoader(TableLoaderSettings settings)
{
- return new GsubTableLoader(settings);
+ var cache = settings._loaderCacheRef;
+ lock (cache.SyncLock)
+ {
+ if (cache.GsubLoader == null)
+ {
+ cache.GsubLoader = new GsubTableLoader(settings);
+ }
+ return cache.GsubLoader;
+ }
}
public static GposTableLoader GetGposTableLoader(TableLoaderSettings settings)
{
- return new GposTableLoader(settings);
+ var cache = settings._loaderCacheRef;
+ lock (cache.SyncLock)
+ {
+ if (cache.GposLoader == null)
+ {
+ cache.GposLoader = new GposTableLoader(settings);
+ }
+ return cache.GposLoader;
+ }
}
}
-}
+}
\ No newline at end of file
From 70dde68c57ab135dd382c54543e484e066aaed9b Mon Sep 17 00:00:00 2001
From: swmal <{ID}+username}@users.noreply.github.com>
Date: Thu, 15 Jan 2026 16:47:20 +0100
Subject: [PATCH 02/18] Started work on text shaper
---
.../FontTestBase.cs | 36 +++
.../Reading/GposReadingTests.cs | 6 +-
.../Reading/TtfReadingTests.cs | 6 +-
.../Regression/RegressionTests.cs | 6 +-
.../Serialization/CmapSerializationTests.cs | 6 +-
.../CoreTableSerializationTests.cs | 6 +-
.../Serialization/GPosSerializationTests.cs | 6 +-
.../GlyphTableSerializationTests.cs | 6 +-
.../Serialization/KernSerializationTests.cs | 6 +-
.../Subsetting/BasicSubsettingTests.cs | 26 +-
.../CompositeGlyphSubsettingTests.cs | 6 +-
.../Subsetting/LigatureSubsettingTests.cs | 22 +-
.../Subsetting/SubsettingEdgeCasesTests.cs | 6 +-
.../Validation/CmapTableValidationTests.cs | 2 +
.../Validation/CoreTableValidationTests.cs | 6 +-
.../Validation/EntireFontValidationTests.cs | 6 +-
.../Validation/GlyphTableValidationTests.cs | 6 +-
.../Validation/GsubTableValidationTests.cs | 6 +-
.../TextShaping/GsubShaper.cs | 11 +
.../TextShaping/KerningProvider.cs | 210 +++++++++++++++
.../TextShaping/ShapedGlyph.cs | 75 ++++++
.../TextShaping/ShapedText.cs | 122 +++++++++
.../TextShaping/ShapingCache.cs | 11 +
.../TextShaping/ShapingOptions.cs | 143 ++++++++++
.../TextShaping/TextShaper.cs | 255 ++++++++++++++++++
25 files changed, 898 insertions(+), 99 deletions(-)
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/GsubShaper.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/KerningProvider.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/ShapedGlyph.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/ShapedText.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/ShapingCache.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/ShapingOptions.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs
diff --git a/src/EPPlus.Fonts.OpenType.Tests/FontTestBase.cs b/src/EPPlus.Fonts.OpenType.Tests/FontTestBase.cs
index d443f2692..b9861ec2a 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/FontTestBase.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/FontTestBase.cs
@@ -19,6 +19,11 @@ namespace EPPlus.Fonts.OpenType.Tests
///
public abstract class FontTestBase
{
+ ///
+ /// Test context will be set by MsTest
+ ///
+ public abstract TestContext? TestContext { get; set; }
+
///
/// Gets the font folder path (for reading test fonts)
///
@@ -47,6 +52,31 @@ protected static FileInfo SaveFont(string fileName, OpenTypeFont font)
return FontDirectoriesTestHelper.SaveFontToOutput(font, fileName);
}
+ ///
+ /// Saves a font to the test output folder using the current test name as filename.
+ /// Automatically appends suffix if provided.
+ /// Skips silently if running in CI/CD environment.
+ ///
+ /// Font to save
+ /// Optional suffix to append (e.g., "fi", "ff")
+ /// FileInfo for saved file, or null if output not available
+ ///
+ /// SaveFontForCurrentTest(subset); // → "Subset_Ff_ShouldHaveFfLigature.ttf"
+ /// SaveFontForCurrentTest(subset, "fi"); // → "Subset_CommonLigatures_ShouldWork_fi.ttf"
+ ///
+ protected FileInfo? SaveFontForCurrentTest(OpenTypeFont font, string suffix = "")
+ {
+ if (!IsTestOutputAvailable)
+ return null;
+
+ var testName = TestContext?.TestName ?? "UnknownTest";
+ var safeSuffix = string.IsNullOrWhiteSpace(suffix) ? "" : $"_{suffix}";
+ var fileName = $"{testName}{safeSuffix}.ttf";
+
+ return FontDirectoriesTestHelper.SaveFontToOutput(font, fileName);
+ }
+
+
///
/// Gets a FileInfo for an output file in a subdirectory.
/// Creates subdirectory if needed.
@@ -84,5 +114,11 @@ public void ClearAllCaches()
{
OpenTypeFonts.ClearFontCache();
}
+
+ [ClassInitialize(InheritanceBehavior.BeforeEachDerivedClass)]
+ public static void BaseClassInitialize(TestContext context)
+ {
+ FontDirectoriesTestHelper.ClassInitialize(context);
+ }
}
}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Reading/GposReadingTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Reading/GposReadingTests.cs
index 71d8d0318..0a2b86bdf 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Reading/GposReadingTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Reading/GposReadingTests.cs
@@ -14,12 +14,8 @@ namespace EPPlus.Fonts.OpenType.Tests.Reading
[TestClass]
public class GposReadingTests : FontTestBase
{
+ public override TestContext? TestContext { get; set; }
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
[TestMethod]
public void ReadGposTable_Roboto()
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Reading/TtfReadingTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Reading/TtfReadingTests.cs
index 7d15d9360..66fc6d5a9 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Reading/TtfReadingTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Reading/TtfReadingTests.cs
@@ -19,11 +19,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Reading
[TestClass]
public sealed class TtfReadingTests : FontTestBase
{
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
[TestMethod]
public void ReadRobotoRegularTtf()
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Regression/RegressionTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Regression/RegressionTests.cs
index 7315e3834..3d775b041 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Regression/RegressionTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Regression/RegressionTests.cs
@@ -27,11 +27,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Regression
[TestClass]
public class RegressionTests : FontTestBase
{
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
[TestMethod]
public void Bug_20251222_CircularLigatureDependency_Roboto()
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Serialization/CmapSerializationTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Serialization/CmapSerializationTests.cs
index e964a734d..30608f5ee 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Serialization/CmapSerializationTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Serialization/CmapSerializationTests.cs
@@ -10,11 +10,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Serialization
[TestClass]
public class CmapSerializationTests : FontTestBase
{
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
[TestMethod]
public void SerializeCmapTable()
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Serialization/CoreTableSerializationTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Serialization/CoreTableSerializationTests.cs
index ab4ffb345..675376699 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Serialization/CoreTableSerializationTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Serialization/CoreTableSerializationTests.cs
@@ -10,11 +10,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Serialization
[TestClass]
public class CoreTableSerializationTests : FontTestBase
{
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
[TestMethod]
public void SerializeHeadTable()
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Serialization/GPosSerializationTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Serialization/GPosSerializationTests.cs
index 81af10661..39d8ed285 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Serialization/GPosSerializationTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Serialization/GPosSerializationTests.cs
@@ -33,11 +33,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Serialization
[TestClass]
public class GposSerializationTests : FontTestBase
{
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
#region Helper Classes for .NET 3.5 Compatibility
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Serialization/GlyphTableSerializationTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Serialization/GlyphTableSerializationTests.cs
index fe50e5b24..ad1b54ac6 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Serialization/GlyphTableSerializationTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Serialization/GlyphTableSerializationTests.cs
@@ -11,11 +11,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Serialization
[TestClass]
public class GlyphTableSerializationTests : FontTestBase
{
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
[TestMethod]
public void SerializeLocaTable()
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Serialization/KernSerializationTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Serialization/KernSerializationTests.cs
index 03dc2d660..4da664f3e 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Serialization/KernSerializationTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Serialization/KernSerializationTests.cs
@@ -10,11 +10,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Serialization
[TestClass]
public class KernSerializationTests : FontTestBase
{
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
[TestMethod]
[Ignore("Was only able to find fonts with kern table among Windows fonts. These cannot be distributed with the test project due to licensing.")]
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Subsetting/BasicSubsettingTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Subsetting/BasicSubsettingTests.cs
index 42348bde1..4770c5212 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Subsetting/BasicSubsettingTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Subsetting/BasicSubsettingTests.cs
@@ -23,11 +23,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Subsetting
[TestClass]
public class BasicSubsettingTests : FontTestBase
{
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
[TestMethod]
public void Subset_Abc_RoundtripValidation()
@@ -42,7 +38,7 @@ public void Subset_Abc_RoundtripValidation()
var parsedFont = new OpenTypeFont(bytes, font.Format);
// Save for inspection
- SaveFont("subset_Roboto_abc.ttf", parsedFont);
+ SaveFontForCurrentTest(parsedFont);
// Assert: Check table presence
Assert.AreEqual(12, parsedFont.TableRecords.Count);
@@ -93,7 +89,7 @@ public void Subset_Fiffig_WithFullValidation()
var parsedFont = new OpenTypeFont(bytes, font.Format);
// Save for inspection
- SaveFont("subset_Roboto_fiffig.ttf", parsedFont);
+ SaveFontForCurrentTest( parsedFont);
// Assert
FontTestHelper.AssertFontValid(parsedFont, FontValidationSeverity.Warning);
@@ -109,7 +105,7 @@ public void Subset_SingleChar_ShouldWork()
var bytes = serializer.Serialize();
var parsedFont = new OpenTypeFont(bytes, font.Format);
- SaveFont("subset_Mulish_a.ttf", parsedFont);
+ SaveFontForCurrentTest(parsedFont);
FontTestHelper.AssertFontValid(parsedFont, FontValidationSeverity.Warning);
}
@@ -127,7 +123,7 @@ public void Subset_MultipleChars_ShouldWork()
var bytes = serializer.Serialize();
var parsedFont = new OpenTypeFont(bytes, font.Format);
- SaveFont("subset_Roboto_flygande_bäckasiner.ttf", parsedFont);
+ SaveFontForCurrentTest(parsedFont);
FontTestHelper.AssertFontValid(parsedFont, FontValidationSeverity.Warning);
}
@@ -138,7 +134,7 @@ public void Subset_RoundtripHelper_ShouldWork()
// Using FontTestHelper.RoundtripSubset
var parsedFont = FontTestHelper.RoundtripSubset("Roboto", "test", FontFolders);
- SaveFont("subset_Roboto_test_via_helper.ttf", parsedFont);
+ SaveFontForCurrentTest(parsedFont);
Assert.IsNotNull(parsedFont);
Assert.IsTrue(parsedFont.MaxpTable.numGlyphs > 0);
@@ -228,7 +224,7 @@ public void Subset_Ligatures_ShouldStillWork()
var bytes = serializer.Serialize();
var parsedFont = new OpenTypeFont(bytes, font.Format);
- SaveFont("subset_Roboto_ligatures_test.ttf", parsedFont);
+ SaveFontForCurrentTest(parsedFont);
Debug.WriteLine("\n=== SUBSET FONT ===");
Debug.WriteLine($"Total glyphs: {parsedFont.MaxpTable.numGlyphs}");
@@ -368,7 +364,7 @@ public void Subset_WithGposKerning_ShouldPreservePositioning()
var bytes = serializer.Serialize();
var parsedFont = new OpenTypeFont(bytes, font.Format);
- SaveFont("subset_Roboto_with_gpos_kerning.ttf", parsedFont);
+ SaveFontForCurrentTest(parsedFont);
// Check SUBSET font
bool foundF = parsedFont.CmapTable.TryGetGlyphId('f', out ushort fGlyph);
@@ -423,7 +419,7 @@ public void Subset_WithGposSingleAdjustment_ShouldPreserve()
var parsedFont = new OpenTypeFont(bytes, font.Format);
// Save for inspection
- SaveFont("subset_Roboto_with_gpos_singleadj.ttf", parsedFont);
+ SaveFontForCurrentTest(parsedFont);
// Assert
FontTestHelper.AssertFontValid(parsedFont, FontValidationSeverity.Warning);
@@ -467,7 +463,7 @@ public void Subset_WithGposMarkToBase_ShouldPreserveAccents()
var parsedFont = new OpenTypeFont(bytes, font.Format);
// Save for inspection
- SaveFont("subset_Roboto_with_gpos_accents.ttf", parsedFont);
+ SaveFontForCurrentTest(parsedFont);
// Assert
FontTestHelper.AssertFontValid(parsedFont, FontValidationSeverity.Warning);
@@ -518,7 +514,7 @@ public void Subset_CompleteGposTest_AllThreeLookupTypes()
var parsedFont = new OpenTypeFont(bytes, font.Format);
// Save for inspection
- SaveFont("subset_Roboto_complete_gpos_test.ttf", parsedFont);
+ SaveFontForCurrentTest(parsedFont);
// Assert
FontTestHelper.AssertFontValid(parsedFont, FontValidationSeverity.Warning);
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Subsetting/CompositeGlyphSubsettingTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Subsetting/CompositeGlyphSubsettingTests.cs
index 71483b2e7..f44dc4ccd 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Subsetting/CompositeGlyphSubsettingTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Subsetting/CompositeGlyphSubsettingTests.cs
@@ -18,11 +18,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Subsetting
[TestClass]
public class CompositeGlyphSubsettingTests : FontTestBase
{
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
[TestMethod]
public void Subset_Roboto_With_ÅÄÖ_Should_Work()
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Subsetting/LigatureSubsettingTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Subsetting/LigatureSubsettingTests.cs
index 2bd41faaa..9cbba3b16 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Subsetting/LigatureSubsettingTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Subsetting/LigatureSubsettingTests.cs
@@ -20,13 +20,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Subsetting
[TestClass]
public class LigatureSubsettingTests : FontTestBase
{
- public TestContext TestContext { get; set; }
-
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
[TestMethod]
public void Subset_Abc_ShouldHaveNoLigatures()
@@ -34,7 +28,7 @@ public void Subset_Abc_ShouldHaveNoLigatures()
var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
var subset = font.CreateSubset(new[] { 'a', 'b', 'c' });
- SaveFont("ligature_test_abc.ttf", subset);
+ SaveFontForCurrentTest(subset);
int ligCount = FontTestHelper.CountLigatures(subset);
Assert.AreEqual(0, ligCount, "abc should have NO ligatures");
@@ -46,7 +40,7 @@ public void Subset_Fiffig_ShouldHaveThreeLigatures()
var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
var subset = font.CreateSubset("fiffig");
- SaveFont("ligature_test_fiffig.ttf", subset);
+ SaveFontForCurrentTest(subset);
int ligCount = FontTestHelper.CountLigatures(subset);
Assert.AreEqual(3, ligCount, "fiffig should have fi, ff, ffi ligatures");
@@ -58,7 +52,7 @@ public void Subset_Fi_ShouldHaveFiLigature()
var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
var subset = font.CreateSubset("fi");
- SaveFont("ligature_test_fi.ttf", subset);
+ SaveFontForCurrentTest(subset);
int ligCount = FontTestHelper.CountLigatures(subset);
Assert.IsTrue(ligCount >= 1, "fi should have at least fi ligature");
@@ -70,7 +64,7 @@ public void Subset_Ff_ShouldHaveFfLigature()
var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
var subset = font.CreateSubset("ff");
- SaveFont("ligature_test_ff.ttf", subset);
+ SaveFontForCurrentTest(subset);
int ligCount = FontTestHelper.CountLigatures(subset);
Assert.IsTrue(ligCount >= 1, "ff should have ff ligature");
@@ -86,7 +80,7 @@ public void Subset_CommonLigatures_ShouldWork(string text)
var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
var subset = font.CreateSubset(text);
- SaveFont($"ligature_test_{text}.ttf", subset);
+ SaveFontForCurrentTest(subset, text);
Assert.IsNotNull(subset);
FontTestHelper.AssertFontValid(subset);
@@ -102,7 +96,7 @@ public void Subset_OnlyF_ShouldNotCrash()
var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
var subset = font.CreateSubset("f");
- SaveFont("ligature_test_f_only.ttf", subset);
+ SaveFontForCurrentTest(subset);
// Should not crash, may or may not have ligatures
Assert.IsNotNull(subset);
@@ -117,7 +111,7 @@ public void Subset_Office_ShouldHaveFfiLigature()
var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
var subset = font.CreateSubset("office");
- SaveFont("ligature_test_office.ttf", subset);
+ SaveFontForCurrentTest(subset);
int ligCount = FontTestHelper.CountLigatures(subset);
Assert.IsTrue(ligCount >= 1, "office should trigger ffi ligature");
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Subsetting/SubsettingEdgeCasesTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Subsetting/SubsettingEdgeCasesTests.cs
index 9bfc613b9..dc9d1944b 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Subsetting/SubsettingEdgeCasesTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Subsetting/SubsettingEdgeCasesTests.cs
@@ -20,11 +20,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Subsetting
[TestClass]
public class SubsettingEdgeCasesTests : FontTestBase
{
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
[TestMethod]
[ExpectedException(typeof(ArgumentException))]
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Validation/CmapTableValidationTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Validation/CmapTableValidationTests.cs
index 56278139f..356024472 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Validation/CmapTableValidationTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Validation/CmapTableValidationTests.cs
@@ -11,6 +11,8 @@ namespace EPPlus.Fonts.OpenType.Tests.Validation
[TestClass]
public class CmapTableValidationTests : FontTestBase
{
+ public override TestContext? TestContext { get; set; }
+
[ClassInitialize]
public static void Initialize(TestContext testContext)
{
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Validation/CoreTableValidationTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Validation/CoreTableValidationTests.cs
index 43261e4cf..b719992fc 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Validation/CoreTableValidationTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Validation/CoreTableValidationTests.cs
@@ -16,11 +16,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Validation
[TestClass]
public class CoreTableValidationTests : FontTestBase
{
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
[TestMethod]
public void HeadTable_Validation_ShouldPass()
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Validation/EntireFontValidationTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Validation/EntireFontValidationTests.cs
index 5b7970ebc..6b7d7d8d6 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Validation/EntireFontValidationTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Validation/EntireFontValidationTests.cs
@@ -6,11 +6,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Validation
[TestClass]
public class EntireFontValidationTests : FontTestBase
{
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
[TestMethod]
public void ValidateEntireFont()
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Validation/GlyphTableValidationTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Validation/GlyphTableValidationTests.cs
index c52c3f219..23bcbb64c 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Validation/GlyphTableValidationTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Validation/GlyphTableValidationTests.cs
@@ -13,11 +13,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Validation
[TestClass]
public class GlyphTableValidationTests : FontTestBase
{
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
[TestMethod]
public void LocaTableValidation_Test()
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Validation/GsubTableValidationTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Validation/GsubTableValidationTests.cs
index bac6a1614..bfe6c285a 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Validation/GsubTableValidationTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Validation/GsubTableValidationTests.cs
@@ -7,11 +7,7 @@ namespace EPPlus.Fonts.OpenType.Tests.Validation
[TestClass]
public class GsubTableValidationTests : FontTestBase
{
- [ClassInitialize]
- public static void Initialize(TestContext testContext)
- {
- FontDirectoriesTestHelper.ClassInitialize(testContext);
- }
+ public override TestContext? TestContext { get; set; }
[TestMethod]
[DataRow("Roboto")]
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/GsubShaper.cs b/src/EPPlus.Fonts.OpenType/TextShaping/GsubShaper.cs
new file mode 100644
index 000000000..43b7c51ff
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/GsubShaper.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace EPPlus.Fonts.OpenType.TextShaping
+{
+ internal class GsubShaper
+ {
+ }
+}
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/KerningProvider.cs b/src/EPPlus.Fonts.OpenType/TextShaping/KerningProvider.cs
new file mode 100644
index 000000000..47a790bed
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/KerningProvider.cs
@@ -0,0 +1,210 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/15/2025 EPPlus Software AB Initial implementation
+ *************************************************************************************************/
+using EPPlus.Fonts.OpenType.Tables.Gpos;
+using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups;
+using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups.LookupType2;
+using EPPlus.Fonts.OpenType.Tables.Kern;
+using System.Collections.Generic;
+
+namespace EPPlus.Fonts.OpenType.TextShaping
+{
+ ///
+ /// Provides kerning information from either GPOS (modern) or kern table (legacy).
+ /// Handles caching and fallback logic.
+ ///
+ internal class KerningProvider
+ {
+ private readonly OpenTypeFont _font;
+ private readonly Dictionary _cache;
+ private readonly bool _hasGpos;
+ private readonly bool _hasKern;
+ private PairPosSubTableFormat1 _gposKerningSubtable;
+
+ public KerningProvider(OpenTypeFont font)
+ {
+ _font = font;
+ _cache = new Dictionary();
+ _hasGpos = font.GposTable != null;
+ _hasKern = font.KernTable != null;
+
+ // Pre-locate GPOS kerning subtable if available
+ if (_hasGpos)
+ {
+ _gposKerningSubtable = FindGposKerningSubtable();
+ }
+ }
+
+ ///
+ /// Gets kerning value for a glyph pair.
+ /// Returns 0 if no kerning is defined.
+ ///
+ /// Left glyph ID
+ /// Right glyph ID
+ /// Kerning adjustment in font units (negative = closer)
+ public short GetKerning(ushort leftGlyph, ushort rightGlyph)
+ {
+ // Check cache first
+ ulong key = MakeCacheKey(leftGlyph, rightGlyph);
+
+ short cachedValue;
+ if (_cache.TryGetValue(key, out cachedValue))
+ {
+ return cachedValue;
+ }
+
+ // Lookup kerning value
+ short kernValue = LookupKerning(leftGlyph, rightGlyph);
+
+ // Cache result (even if 0, to avoid repeated lookups)
+ _cache[key] = kernValue;
+
+ return kernValue;
+ }
+
+ ///
+ /// Clears the kerning cache.
+ /// Call this if you need to free memory.
+ ///
+ public void ClearCache()
+ {
+ _cache.Clear();
+ }
+
+ #region Private Methods
+
+ private short LookupKerning(ushort leftGlyph, ushort rightGlyph)
+ {
+ // Try GPOS first (modern, preferred)
+ if (_hasGpos && _gposKerningSubtable != null)
+ {
+ short gposKern = GetGposKerning(leftGlyph, rightGlyph);
+ if (gposKern != 0)
+ {
+ return gposKern;
+ }
+ }
+
+ // Fallback to kern table (legacy)
+ if (_hasKern)
+ {
+ return GetLegacyKerning(leftGlyph, rightGlyph);
+ }
+
+ return 0;
+ }
+
+ private short GetGposKerning(ushort leftGlyph, ushort rightGlyph)
+ {
+ if (_gposKerningSubtable == null)
+ return 0;
+
+ ValueRecord value1, value2;
+ if (_gposKerningSubtable.TryGetPairAdjustment(leftGlyph, rightGlyph, out value1, out value2))
+ {
+ // Kerning is typically in value1.XAdvance
+ return value1.XAdvance;
+ }
+
+ return 0;
+ }
+
+ private short GetLegacyKerning(ushort leftGlyph, ushort rightGlyph)
+ {
+ var kernTable = _font.KernTable;
+ if (kernTable == null || kernTable.SubTables == null || kernTable.SubTables.Count == 0)
+ return 0;
+
+ // Iterate through subtables
+ foreach (var subtable in kernTable.SubTables)
+ {
+ // Only support Format 0 (horizontal kerning)
+ if (subtable.coverage.Format == 0 && subtable.Format0Subtable != null)
+ {
+ short kernValue = GetKerningFromFormat0(subtable.Format0Subtable, leftGlyph, rightGlyph);
+ if (kernValue != 0)
+ {
+ return kernValue;
+ }
+ }
+ }
+
+ return 0;
+ }
+
+ private short GetKerningFromFormat0(KernSubTableFormat0 format0, ushort leftGlyph, ushort rightGlyph)
+ {
+ if (format0.Pairs == null)
+ return 0;
+
+ // Linear search through kerning pairs
+ // Note: Could be optimized with binary search if pairs are sorted
+ foreach (var pair in format0.Pairs)
+ {
+ if (pair.left == leftGlyph && pair.right == rightGlyph)
+ {
+ return pair.value;
+ }
+ }
+
+ return 0;
+ }
+
+ private PairPosSubTableFormat1 FindGposKerningSubtable()
+ {
+ var gpos = _font.GposTable;
+ if (gpos == null) return null;
+
+ // Find "kern" feature
+ foreach (var featureRecord in gpos.FeatureList.FeatureRecords)
+ {
+ if (featureRecord.FeatureTag.Value == "kern")
+ {
+ var feature = featureRecord.FeatureTable;
+
+ // Get lookups for this feature
+ foreach (var lookupIndex in feature.LookupListIndices)
+ {
+ if (lookupIndex >= gpos.LookupList.Lookups.Count)
+ continue;
+
+ var lookup = gpos.LookupList.Lookups[lookupIndex];
+
+ // We want PairPos (Type 2)
+ if (lookup.LookupType == 2)
+ {
+ // Return first PairPos Format 1 subtable
+ foreach (var subtable in lookup.SubTables)
+ {
+ var pairPos = subtable as PairPosSubTableFormat1;
+ if (pairPos != null)
+ {
+ return pairPos;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return null;
+ }
+
+ private static ulong MakeCacheKey(ushort leftGlyph, ushort rightGlyph)
+ {
+ // Combine two ushorts into one ulong for fast dictionary lookup
+ return ((ulong)leftGlyph << 16) | rightGlyph;
+ }
+
+ #endregion
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/ShapedGlyph.cs b/src/EPPlus.Fonts.OpenType/TextShaping/ShapedGlyph.cs
new file mode 100644
index 000000000..0e55c54f3
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/ShapedGlyph.cs
@@ -0,0 +1,75 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/15/2025 EPPlus Software AB Initial implementation
+ *************************************************************************************************/
+
+namespace EPPlus.Fonts.OpenType.TextShaping
+{
+ ///
+ /// Represents a shaped glyph with positioning information.
+ /// All measurements are in font units (not PDF points or pixels).
+ ///
+ public struct ShapedGlyph
+ {
+ ///
+ /// The glyph ID in the font.
+ ///
+ public ushort GlyphId { get; set; }
+
+ ///
+ /// Horizontal advance width in font units.
+ /// This includes any kerning adjustments from GPOS.
+ ///
+ public int XAdvance { get; set; }
+
+ ///
+ /// Vertical advance height in font units.
+ /// Typically 0 for horizontal text.
+ ///
+ public int YAdvance { get; set; }
+
+ ///
+ /// Horizontal offset adjustment in font units.
+ /// Used for positioning marks, subscripts, superscripts.
+ ///
+ public int XOffset { get; set; }
+
+ ///
+ /// Vertical offset adjustment in font units.
+ /// Used for positioning marks, subscripts, superscripts.
+ ///
+ public int YOffset { get; set; }
+
+ ///
+ /// Index of the original character(s) that produced this glyph.
+ /// Used for text selection and editing.
+ /// For ligatures, this points to the first character.
+ ///
+ public int ClusterIndex { get; set; }
+
+ ///
+ /// Number of characters consumed by this glyph.
+ /// 1 for normal glyphs, 2+ for ligatures (e.g., "fi" → 1 glyph, 2 chars).
+ ///
+ public int CharCount { get; set; }
+
+ public ShapedGlyph(ushort glyphId, int xAdvance)
+ {
+ GlyphId = glyphId;
+ XAdvance = xAdvance;
+ YAdvance = 0;
+ XOffset = 0;
+ YOffset = 0;
+ ClusterIndex = 0;
+ CharCount = 1;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/ShapedText.cs b/src/EPPlus.Fonts.OpenType/TextShaping/ShapedText.cs
new file mode 100644
index 000000000..033fc76c8
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/ShapedText.cs
@@ -0,0 +1,122 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/15/2025 EPPlus Software AB Initial implementation
+ *************************************************************************************************/
+using System;
+using System.Text;
+
+namespace EPPlus.Fonts.OpenType.TextShaping
+{
+ ///
+ /// Result of text shaping operation containing positioned glyphs.
+ ///
+ public class ShapedText
+ {
+ ///
+ /// Array of shaped glyphs with positioning information.
+ ///
+ public ShapedGlyph[] Glyphs { get; set; }
+
+ ///
+ /// The original input text that was shaped.
+ ///
+ public string OriginalText { get; set; }
+
+ ///
+ /// Total horizontal advance width in font units.
+ /// This is the sum of all glyph XAdvance values.
+ ///
+ public int TotalAdvanceWidth
+ {
+ get
+ {
+ int total = 0;
+ if (Glyphs != null)
+ {
+ foreach (var glyph in Glyphs)
+ {
+ total += glyph.XAdvance;
+ }
+ }
+ return total;
+ }
+ }
+
+ ///
+ /// Convert total advance width to PDF points.
+ ///
+ /// Font size in points
+ /// Units per EM from font head table
+ /// Width in PDF points
+ public float GetWidthInPoints(float fontSize, float unitsPerEm)
+ {
+ return (TotalAdvanceWidth / unitsPerEm) * fontSize;
+ }
+
+ ///
+ /// Convert total advance width to pixels.
+ ///
+ /// Font size in points
+ /// Screen DPI (typically 96 or 72)
+ /// Units per EM from font head table
+ /// Width in pixels
+ public float GetWidthInPixels(float fontSize, float dpi, float unitsPerEm)
+ {
+ float points = GetWidthInPoints(fontSize, unitsPerEm);
+ return points * (dpi / 72f);
+ }
+
+ ///
+ /// Generate PDF text operators for rendering this shaped text.
+ ///
+ /// Font size in points
+ /// Starting X position in PDF coordinates
+ /// Starting Y position in PDF coordinates
+ /// Units per EM from font head table
+ /// PDF operator string
+ public string ToPdfOperators(float fontSize, float x, float y, float unitsPerEm)
+ {
+ var sb = new StringBuilder();
+
+ sb.AppendLine("BT");
+ sb.AppendFormat("/F1 {0} Tf\n", fontSize);
+ sb.AppendFormat("{0} {1} Td\n", x, y);
+
+ foreach (var glyph in Glyphs)
+ {
+ // Show glyph (using glyph ID)
+ sb.AppendFormat("<{0:X4}> Tj\n", glyph.GlyphId);
+
+ // Calculate advance in PDF points
+ float advanceX = (glyph.XAdvance / unitsPerEm) * fontSize;
+
+ // Apply Y-offset if present (for subscript/superscript)
+ if (Math.Abs(glyph.YOffset) > 0.001f)
+ {
+ float offsetY = (glyph.YOffset / unitsPerEm) * fontSize;
+ sb.AppendFormat("0 {0:F3} Td\n", offsetY);
+ }
+
+ // Advance to next position
+ sb.AppendFormat("{0:F3} 0 Td\n", advanceX);
+ }
+
+ sb.AppendLine("ET");
+ return sb.ToString();
+ }
+
+ public ShapedText()
+ {
+ Glyphs = new ShapedGlyph[0];
+ OriginalText = string.Empty;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/ShapingCache.cs b/src/EPPlus.Fonts.OpenType/TextShaping/ShapingCache.cs
new file mode 100644
index 000000000..3628cb316
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/ShapingCache.cs
@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace EPPlus.Fonts.OpenType.TextShaping
+{
+ internal class ShapingCache
+ {
+ }
+}
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/ShapingOptions.cs b/src/EPPlus.Fonts.OpenType/TextShaping/ShapingOptions.cs
new file mode 100644
index 000000000..d935204bd
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/ShapingOptions.cs
@@ -0,0 +1,143 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/15/2025 EPPlus Software AB Initial implementation
+ *************************************************************************************************/
+using System.Collections.Generic;
+
+namespace EPPlus.Fonts.OpenType.TextShaping
+{
+ ///
+ /// Options for controlling text shaping behavior.
+ ///
+ public class ShapingOptions
+ {
+ ///
+ /// Whether to apply GSUB substitutions (ligatures, contextual alternates, etc.).
+ ///
+ public bool ApplySubstitutions { get; set; }
+
+ ///
+ /// List of GSUB features to apply (e.g., "liga", "calt", "clig").
+ /// If null or empty, all available features will be applied.
+ ///
+ public List GsubFeatures { get; set; }
+
+ ///
+ /// Whether to apply GPOS positioning (kerning, mark positioning, etc.).
+ ///
+ public bool ApplyPositioning { get; set; }
+
+ ///
+ /// List of GPOS features to apply (e.g., "kern", "mark").
+ /// If null or empty, all available features will be applied.
+ ///
+ public List GposFeatures { get; set; }
+
+ ///
+ /// Script tag for shaping (e.g., "latn" for Latin).
+ /// If null, will use default script.
+ ///
+ public string Script { get; set; }
+
+ ///
+ /// Language tag for shaping (e.g., "SWE " for Swedish).
+ /// If null, will use default language.
+ ///
+ public string Language { get; set; }
+
+ ///
+ /// Default shaping options: ligatures and kerning enabled.
+ ///
+ public static ShapingOptions Default
+ {
+ get
+ {
+ return new ShapingOptions
+ {
+ ApplySubstitutions = true,
+ GsubFeatures = new List { "liga" },
+ ApplyPositioning = true,
+ GposFeatures = new List { "kern" },
+ Script = "latn",
+ Language = null
+ };
+ }
+ }
+
+ ///
+ /// Fast shaping: no substitutions, only kerning.
+ /// Use for simple text measurement where ligatures are not important.
+ ///
+ public static ShapingOptions Fast
+ {
+ get
+ {
+ return new ShapingOptions
+ {
+ ApplySubstitutions = false,
+ GsubFeatures = null,
+ ApplyPositioning = true,
+ GposFeatures = new List { "kern" },
+ Script = "latn",
+ Language = null
+ };
+ }
+ }
+
+ ///
+ /// Full shaping: all features enabled.
+ /// Use for high-quality rendering.
+ ///
+ public static ShapingOptions Full
+ {
+ get
+ {
+ return new ShapingOptions
+ {
+ ApplySubstitutions = true,
+ GsubFeatures = new List { "liga", "calt", "clig" },
+ ApplyPositioning = true,
+ GposFeatures = new List { "kern", "mark" },
+ Script = "latn",
+ Language = null
+ };
+ }
+ }
+
+ ///
+ /// No shaping: just map characters to glyphs.
+ /// Fastest option, but no ligatures or kerning.
+ ///
+ public static ShapingOptions None
+ {
+ get
+ {
+ return new ShapingOptions
+ {
+ ApplySubstitutions = false,
+ GsubFeatures = null,
+ ApplyPositioning = false,
+ GposFeatures = null,
+ Script = null,
+ Language = null
+ };
+ }
+ }
+
+ public ShapingOptions()
+ {
+ ApplySubstitutions = true;
+ ApplyPositioning = true;
+ GsubFeatures = new List();
+ GposFeatures = new List();
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs b/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs
new file mode 100644
index 000000000..dc5f27d56
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs
@@ -0,0 +1,255 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/15/2025 EPPlus Software AB Initial implementation
+ *************************************************************************************************/
+using EPPlus.Fonts.OpenType.Tables.Cmap;
+using EPPlus.Fonts.OpenType.Tables.Hmtx;
+using System;
+using System.Collections.Generic;
+
+namespace EPPlus.Fonts.OpenType.TextShaping
+{
+ ///
+ /// Text shaping engine that converts text strings to positioned glyphs.
+ /// Handles character-to-glyph mapping, GSUB substitutions, and GPOS positioning.
+ ///
+ public class TextShaper
+ {
+ private readonly OpenTypeFont _font;
+ private readonly KerningProvider _kerningProvider;
+
+ ///
+ /// Creates a new text shaper for the specified font.
+ ///
+ /// The OpenType font to use for shaping
+ public TextShaper(OpenTypeFont font)
+ {
+ _font = font ?? throw new ArgumentNullException(nameof(font));
+ _kerningProvider = new KerningProvider(font);
+ }
+
+ ///
+ /// Shape text using default options (ligatures + kerning).
+ ///
+ /// Text to shape
+ /// Shaped text with positioned glyphs
+ public ShapedText Shape(string text)
+ {
+ return Shape(text, ShapingOptions.Default);
+ }
+
+ ///
+ /// Shape text with specified options.
+ ///
+ /// Text to shape
+ /// Shaping options
+ /// Shaped text with positioned glyphs
+ public ShapedText Shape(string text, ShapingOptions options)
+ {
+ if (string.IsNullOrEmpty(text))
+ {
+ return new ShapedText
+ {
+ OriginalText = text ?? string.Empty,
+ Glyphs = new ShapedGlyph[0]
+ };
+ }
+
+ if (options == null)
+ {
+ options = ShapingOptions.Default;
+ }
+
+ // Phase 1: Map characters to glyphs
+ var glyphs = MapToGlyphs(text);
+
+ // Phase 2: Apply GSUB substitutions (if enabled)
+ if (options.ApplySubstitutions && _font.GsubTable != null)
+ {
+ glyphs = ApplyGsubSubstitutions(glyphs, options);
+ }
+
+ // Phase 3: Apply GPOS positioning (if enabled)
+ if (options.ApplyPositioning)
+ {
+ ApplyPositioning(glyphs, options);
+ }
+
+ // Phase 4: Build result
+ return new ShapedText
+ {
+ OriginalText = text,
+ Glyphs = glyphs.ToArray()
+ };
+ }
+
+ #region Phase 1: Character to Glyph Mapping
+
+ ///
+ /// Maps characters to glyphs using the cmap table.
+ ///
+ private List MapToGlyphs(string text)
+ {
+ var glyphs = new List(text.Length);
+ var cmapTable = _font.CmapTable;
+ var hmtxTable = _font.HmtxTable;
+
+ for (int i = 0; i < text.Length; i++)
+ {
+ char c = text[i];
+
+ // Map character to glyph ID
+ int glyphId = cmapTable.MapCharToGlyph(c);
+
+ // Handle missing glyphs (use .notdef)
+ if (glyphId < 0)
+ {
+ glyphId = 0; // .notdef
+ }
+
+ // Get advance width from hmtx
+ int advanceWidth = hmtxTable.GetAdvanceWidth((ushort)glyphId);
+
+ glyphs.Add(new ShapedGlyph
+ {
+ GlyphId = (ushort)glyphId,
+ XAdvance = advanceWidth,
+ YAdvance = 0,
+ XOffset = 0,
+ YOffset = 0,
+ ClusterIndex = i,
+ CharCount = 1
+ });
+ }
+
+ return glyphs;
+ }
+
+ #endregion
+
+ #region Phase 2: GSUB Substitutions
+
+ ///
+ /// Applies GSUB substitutions (ligatures, contextual alternates, etc.).
+ ///
+ private List ApplyGsubSubstitutions(List glyphs, ShapingOptions options)
+ {
+ // TODO: Implement in next step
+ // For now, just apply ligatures if "liga" feature is requested
+
+ if (options.GsubFeatures != null && options.GsubFeatures.Contains("liga"))
+ {
+ glyphs = ApplyLigatures(glyphs);
+ }
+
+ return glyphs;
+ }
+
+ ///
+ /// Applies standard ligature substitutions (fi, ff, ffi, etc.).
+ ///
+ private List ApplyLigatures(List glyphs)
+ {
+ // TODO: Implement ligature lookup
+ // For now, return unchanged
+ return glyphs;
+ }
+
+ #endregion
+
+ #region Phase 3: Positioning
+
+ ///
+ /// Applies positioning adjustments (kerning, mark positioning, etc.).
+ ///
+ private void ApplyPositioning(List glyphs, ShapingOptions options)
+ {
+ // Apply kerning if requested
+ if (options.GposFeatures != null && options.GposFeatures.Contains("kern"))
+ {
+ ApplyKerning(glyphs);
+ }
+
+ // TODO: Add support for other GPOS features (mark, mkmk, etc.)
+ }
+
+ ///
+ /// Applies kerning adjustments to glyph pairs.
+ /// Uses KerningProvider which handles both GPOS and legacy kern table.
+ ///
+ private void ApplyKerning(List glyphs)
+ {
+ for (int i = 1; i < glyphs.Count; i++)
+ {
+ ushort leftGlyph = glyphs[i - 1].GlyphId;
+ ushort rightGlyph = glyphs[i].GlyphId;
+
+ // Get kerning value (handles GPOS + kern table + caching)
+ short kernValue = _kerningProvider.GetKerning(leftGlyph, rightGlyph);
+
+ if (kernValue != 0)
+ {
+ // Apply kerning to the left glyph's advance
+ var glyph = glyphs[i - 1];
+ glyph.XAdvance += kernValue;
+ glyphs[i - 1] = glyph;
+ }
+ }
+ }
+
+ #endregion
+
+ #region Utilities
+
+ ///
+ /// Measures the width of text in font units.
+ ///
+ /// Text to measure
+ /// Shaping options
+ /// Width in font units
+ public int MeasureText(string text, ShapingOptions options = null)
+ {
+ var shaped = Shape(text, options);
+ return shaped.TotalAdvanceWidth;
+ }
+
+ ///
+ /// Measures the width of text in PDF points.
+ ///
+ /// Text to measure
+ /// Font size in points
+ /// Shaping options
+ /// Width in PDF points
+ public float MeasureTextInPoints(string text, float fontSize, ShapingOptions options = null)
+ {
+ var shaped = Shape(text, options);
+ float unitsPerEm = _font.HeadTable.UnitsPerEm;
+ return shaped.GetWidthInPoints(fontSize, unitsPerEm);
+ }
+
+ ///
+ /// Measures the width of text in pixels.
+ ///
+ /// Text to measure
+ /// Font size in points
+ /// Screen DPI (typically 96)
+ /// Shaping options
+ /// Width in pixels
+ public float MeasureTextInPixels(string text, float fontSize, float dpi, ShapingOptions options = null)
+ {
+ var shaped = Shape(text, options);
+ float unitsPerEm = _font.HeadTable.UnitsPerEm;
+ return shaped.GetWidthInPixels(fontSize, dpi, unitsPerEm);
+ }
+
+ #endregion
+ }
+}
\ No newline at end of file
From aba33a1fd7c5b37fafdf90dd2706fd5ed4cbd61d Mon Sep 17 00:00:00 2001
From: swmal <{ID}+username}@users.noreply.github.com>
Date: Fri, 16 Jan 2026 15:22:34 +0100
Subject: [PATCH 03/18] First working version of TextShaper
---
.../Subsetting/SubsettingEdgeCasesTests.cs | 20 +
.../TextShaping/TextShaperTests.cs | 653 ++++++++++++++++++
.../Integration/OpenTypeFontTextMeasurer.cs | 89 +++
.../Common/Layout/ClassDef/ClassDefFormat1.cs | 53 ++
.../Common/Layout/ClassDef/ClassDefFormat2.cs | 56 ++
.../Common/Layout/ClassDef/ClassDefTable.cs | 46 ++
.../Layout/ClassDef/ClassRangeRecord.cs | 38 +
.../ClassDef/IO/ClassDefTableDeserializer.cs | 104 +++
.../LookupType2/PairPosSubTableFormat2.cs | 202 ++++++
.../PairPosSubTableFormat2Deserializer.cs | 109 +++
.../Tables/Gpos/GposTableLoader.cs | 10 +-
.../Tables/Gpos/Handlers/PairPosHandler.cs | 132 +++-
.../Gsub/IO/ChainingContextualDeserializer.cs | 3 +
.../TextShaping/KerningProvider.cs | 72 +-
.../TextShaping/LigatureProcessor.cs | 208 ++++++
.../TextShaping/MultiLineMetrics.cs | 46 ++
.../TextShaping/ShapedGlyph.cs | 28 +-
.../TextShaping/TextShaper.cs | 125 +++-
18 files changed, 1897 insertions(+), 97 deletions(-)
create mode 100644 src/EPPlus.Fonts.OpenType.Tests/TextShaping/TextShaperTests.cs
create mode 100644 src/EPPlus.Fonts.OpenType/Integration/OpenTypeFontTextMeasurer.cs
create mode 100644 src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefFormat1.cs
create mode 100644 src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefFormat2.cs
create mode 100644 src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefTable.cs
create mode 100644 src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassRangeRecord.cs
create mode 100644 src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/IO/ClassDefTableDeserializer.cs
create mode 100644 src/EPPlus.Fonts.OpenType/Tables/Gpos/Data/Lookups/LookupType2/PairPosSubTableFormat2.cs
create mode 100644 src/EPPlus.Fonts.OpenType/Tables/Gpos/Data/Lookups/LookupType2/PairPosSubTableFormat2Deserializer.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/LigatureProcessor.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/MultiLineMetrics.cs
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Subsetting/SubsettingEdgeCasesTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Subsetting/SubsettingEdgeCasesTests.cs
index dc9d1944b..fc60eca42 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Subsetting/SubsettingEdgeCasesTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Subsetting/SubsettingEdgeCasesTests.cs
@@ -10,7 +10,9 @@ Date Author Change
*************************************************************************************************
12/22/2025 EPPlus Software AB Subsetting edge case tests
*************************************************************************************************/
+using EPPlus.Fonts.OpenType.Subsetting;
using EPPlus.Fonts.OpenType.Tests.Helpers;
+using EPPlus.Fonts.OpenType.TextShaping;
using System;
using System.Collections.Generic;
using System.Linq;
@@ -108,5 +110,23 @@ public void Subset_AllGlyphs_ShouldBeSimilarSizeToOriginal()
Assert.IsTrue(ratio > 0.8,
$"Full subset unexpectedly small: {ratio:P0} of original");
}
+
+ [TestMethod]
+ public void Subset_PreservesRobotoKerning()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var builder = new SubsetFontBuilder();
+
+ // Act
+ var subset = font.CreateSubset("AV");
+ var shaper = new TextShaper(subset);
+ var result = shaper.Shape("AV");
+
+ // Assert
+ Assert.IsTrue(result.Glyphs[0].XAdvance < font.HmtxTable.GetAdvanceWidth(
+ font.CmapTable.MapCharToGlyph('A')),
+ "Subset should preserve A-V kerning");
+ }
}
}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType.Tests/TextShaping/TextShaperTests.cs b/src/EPPlus.Fonts.OpenType.Tests/TextShaping/TextShaperTests.cs
new file mode 100644
index 000000000..55baa93ca
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType.Tests/TextShaping/TextShaperTests.cs
@@ -0,0 +1,653 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/16/2025 EPPlus Software AB TextShaper tests
+ *************************************************************************************************/
+using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups.LookupType2;
+using EPPlus.Fonts.OpenType.TextShaping;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.Diagnostics;
+
+namespace EPPlus.Fonts.OpenType.Tests.TextShaping
+{
+ [TestClass]
+ public class TextShaperTests : FontTestBase
+ {
+ public override TestContext? TestContext { get; set; }
+
+ #region Basic Shaping Tests
+
+ [TestMethod]
+ public void Shape_EmptyString_ReturnsEmptyResult()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var shaped = shaper.Shape("");
+
+ // Assert
+ Assert.IsNotNull(shaped);
+ Assert.AreEqual("", shaped.OriginalText);
+ Assert.AreEqual(0, shaped.Glyphs.Length);
+ Assert.AreEqual(0, shaped.TotalAdvanceWidth);
+ }
+
+ [TestMethod]
+ public void Shape_NullString_ReturnsEmptyResult()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var shaped = shaper.Shape(null);
+
+ // Assert
+ Assert.IsNotNull(shaped);
+ Assert.AreEqual("", shaped.OriginalText);
+ Assert.AreEqual(0, shaped.Glyphs.Length);
+ }
+
+ [TestMethod]
+ public void Shape_SingleCharacter_ReturnsOneGlyph()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var shaped = shaper.Shape("A");
+
+ // Assert
+ Assert.IsNotNull(shaped);
+ Assert.AreEqual("A", shaped.OriginalText);
+ Assert.AreEqual(1, shaped.Glyphs.Length);
+ Assert.IsTrue(shaped.Glyphs[0].GlyphId > 0, "Should have valid glyph ID");
+ Assert.IsTrue(shaped.Glyphs[0].XAdvance > 0, "Should have positive advance width");
+ }
+
+ [TestMethod]
+ public void Shape_SimpleWord_ReturnsCorrectGlyphCount()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var shaped = shaper.Shape("Hello");
+
+ // Assert
+ Assert.IsNotNull(shaped);
+ Assert.AreEqual("Hello", shaped.OriginalText);
+ Assert.AreEqual(5, shaped.Glyphs.Length);
+ Assert.IsTrue(shaped.TotalAdvanceWidth > 0);
+ }
+
+ [TestMethod]
+ public void Shape_WithSpace_IncludesSpaceGlyph()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var shaped = shaper.Shape("A B");
+
+ // Assert
+ Assert.AreEqual(3, shaped.Glyphs.Length);
+ Assert.IsTrue(shaped.Glyphs[1].XAdvance > 0, "Space should have advance width");
+ }
+
+ #endregion
+
+ #region Kerning Tests
+
+ [TestMethod]
+ public void Shape_WithKerning_ReducesWidth()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var withKerning = shaper.Shape("WAVE", ShapingOptions.Default);
+ var withoutKerning = shaper.Shape("WAVE", ShapingOptions.None);
+
+ // Assert
+ Assert.IsTrue(withKerning.TotalAdvanceWidth < withoutKerning.TotalAdvanceWidth,
+ "Kerning should reduce width for 'WAVE'");
+ }
+
+ [TestMethod]
+ public void Debug_GposKerningFormat()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+
+ Assert.IsNotNull(font.GposTable, "Should have GPOS");
+
+ // Find kern feature
+ foreach (var featureRecord in font.GposTable.FeatureList.FeatureRecords)
+ {
+ if (featureRecord.FeatureTag.Value == "kern")
+ {
+ Debug.WriteLine("Found 'kern' feature");
+
+ var feature = featureRecord.FeatureTable;
+ foreach (var lookupIndex in feature.LookupListIndices)
+ {
+ var lookup = font.GposTable.LookupList.Lookups[lookupIndex];
+ Debug.WriteLine($"Lookup type: {lookup.LookupType}");
+
+ foreach (var subtable in lookup.SubTables)
+ {
+ Debug.WriteLine($"Subtable type: {subtable.GetType().Name}");
+
+ if (subtable is PairPosSubTableFormat1 format1)
+ {
+ Debug.WriteLine($" Format 1: {format1.PairSets.Count} pair sets");
+ }
+ else if (subtable is PairPosSubTableFormat2 format2)
+ {
+ Debug.WriteLine($" Format 2: Class-based kerning");
+ Debug.WriteLine($" ClassDef1 glyphs: {format2.ClassDef1?.GetType().Name}");
+ Debug.WriteLine($" ClassDef2 glyphs: {format2.ClassDef2?.GetType().Name}");
+ Debug.WriteLine($" Class1 count: {format2.Class1Count}");
+ Debug.WriteLine($" Class2 count: {format2.Class2Count}");
+ }
+ }
+ }
+ }
+ }
+ }
+
+ [TestMethod]
+ public void Shape_AVPair_HasNegativeKerning()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var withKerning = shaper.Shape("AV");
+ var withoutKerning = shaper.Shape("AV", ShapingOptions.None);
+
+ // Assert
+ Assert.IsTrue(withKerning.TotalAdvanceWidth < withoutKerning.TotalAdvanceWidth,
+ "A-V pair should have negative kerning");
+
+ // Check that first glyph (A) has reduced advance
+ Assert.IsTrue(withKerning.Glyphs[0].XAdvance < withoutKerning.Glyphs[0].XAdvance,
+ "First glyph should have kerning applied");
+ }
+
+ [TestMethod]
+ public void Shape_FastOption_StillAppliesKerning()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var fast = shaper.Shape("WAVE", ShapingOptions.Fast);
+ var none = shaper.Shape("WAVE", ShapingOptions.None);
+
+ // Assert
+ Assert.IsTrue(fast.TotalAdvanceWidth < none.TotalAdvanceWidth,
+ "Fast option should still apply kerning");
+ }
+
+ #endregion
+
+ #region Measurement Tests
+
+ [TestMethod]
+ public void MeasureText_ReturnsPositiveWidth()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ int width = shaper.MeasureText("Hello");
+
+ // Assert
+ Assert.IsTrue(width > 0, "Width should be positive");
+ }
+
+ [TestMethod]
+ public void MeasureTextInPoints_ReturnsReasonableValue()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ float width = shaper.MeasureTextInPoints("Hello", 12);
+
+ // Assert
+ Assert.IsTrue(width > 10, "Should be at least 10 points wide");
+ Assert.IsTrue(width < 100, "Should be less than 100 points wide");
+ }
+
+ [TestMethod]
+ public void MeasureTextInPixels_ScalesWithDpi()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ float width72 = shaper.MeasureTextInPixels("Hello", 12, 72);
+ float width96 = shaper.MeasureTextInPixels("Hello", 12, 96);
+
+ // Assert
+ Assert.IsTrue(width96 > width72, "96 DPI should be wider than 72 DPI");
+ Assert.AreEqual(96.0f / 72.0f, width96 / width72, 0.01, "Should scale proportionally");
+ }
+
+ [TestMethod]
+ public void MeasureText_LargerFontSize_LargerWidth()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ float width12 = shaper.MeasureTextInPoints("Hello", 12);
+ float width24 = shaper.MeasureTextInPoints("Hello", 24);
+
+ // Assert
+ Assert.IsTrue(width24 > width12 * 1.9, "24pt should be ~2x wider than 12pt");
+ Assert.IsTrue(width24 < width12 * 2.1, "24pt should be ~2x wider than 12pt");
+ }
+
+ #endregion
+
+ #region Glyph Properties Tests
+
+ [TestMethod]
+ public void Shape_GlyphsHaveClusterIndices()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var shaped = shaper.Shape("ABC");
+
+ // Assert
+ Assert.AreEqual(0, shaped.Glyphs[0].ClusterIndex);
+ Assert.AreEqual(1, shaped.Glyphs[1].ClusterIndex);
+ Assert.AreEqual(2, shaped.Glyphs[2].ClusterIndex);
+ }
+
+ [TestMethod]
+ public void Shape_GlyphsHaveCharCount()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var shaped = shaper.Shape("ABC");
+
+ // Assert
+ foreach (var glyph in shaped.Glyphs)
+ {
+ Assert.AreEqual(1, glyph.CharCount, "Simple glyphs should have CharCount=1");
+ }
+ }
+
+ [TestMethod]
+ public void Shape_GlyphsHaveValidIds()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var shaped = shaper.Shape("Hello");
+
+ // Assert
+ foreach (var glyph in shaped.Glyphs)
+ {
+ Assert.IsTrue(glyph.GlyphId < font.MaxpTable.numGlyphs,
+ "Glyph ID should be within font bounds");
+ }
+ }
+
+ #endregion
+
+ #region Multi-line Tests
+
+ [TestMethod]
+ public void ShapeLines_SingleLine_ReturnsOneElement()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var lines = shaper.ShapeLines("Hello");
+
+ // Assert
+ Assert.AreEqual(1, lines.Length);
+ Assert.AreEqual("Hello", lines[0].OriginalText);
+ }
+
+ [TestMethod]
+ public void ShapeLines_TwoLinesWithLF_ReturnsTwoElements()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var lines = shaper.ShapeLines("Hello\nWorld");
+
+ // Assert
+ Assert.AreEqual(2, lines.Length);
+ Assert.AreEqual("Hello", lines[0].OriginalText);
+ Assert.AreEqual("World", lines[1].OriginalText);
+ }
+
+ [TestMethod]
+ public void ShapeLines_TwoLinesWithCRLF_ReturnsTwoElements()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var lines = shaper.ShapeLines("Hello\r\nWorld");
+
+ // Assert
+ Assert.AreEqual(2, lines.Length);
+ Assert.AreEqual("Hello", lines[0].OriginalText);
+ Assert.AreEqual("World", lines[1].OriginalText);
+ }
+
+ [TestMethod]
+ public void ShapeLines_EmptyLine_PreservesEmptyLine()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var lines = shaper.ShapeLines("Hello\n\nWorld");
+
+ // Assert
+ Assert.AreEqual(3, lines.Length);
+ Assert.AreEqual("Hello", lines[0].OriginalText);
+ Assert.AreEqual("", lines[1].OriginalText);
+ Assert.AreEqual("World", lines[2].OriginalText);
+ }
+
+ [TestMethod]
+ public void MeasureLines_SingleLine_MatchesSingleMeasurement()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var metrics = shaper.MeasureLines("Hello", 12);
+ float singleWidth = shaper.MeasureTextInPoints("Hello", 12);
+
+ // Assert
+ Assert.AreEqual(1, metrics.LineCount);
+ Assert.AreEqual(singleWidth, metrics.Width, 0.01f);
+ }
+
+ [TestMethod]
+ public void MeasureLines_TwoLines_WidthIsMaxOfBoth()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var metrics = shaper.MeasureLines("Hi\nHello", 12);
+ float hiWidth = shaper.MeasureTextInPoints("Hi", 12);
+ float helloWidth = shaper.MeasureTextInPoints("Hello", 12);
+
+ // Assert
+ Assert.AreEqual(2, metrics.LineCount);
+ Assert.AreEqual(Math.Max(hiWidth, helloWidth), metrics.Width, 0.01f);
+ }
+
+ [TestMethod]
+ public void MeasureLines_TwoLines_HeightIsDoubleLineHeight()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var metrics = shaper.MeasureLines("Hello\nWorld", 12);
+ float lineHeight = shaper.GetLineHeightInPoints(12);
+
+ // Assert
+ Assert.AreEqual(2, metrics.LineCount);
+ Assert.AreEqual(2 * lineHeight, metrics.Height, 0.01f);
+ }
+
+ #endregion
+
+ #region Height Calculation Tests
+
+ [TestMethod]
+ public void GetLineHeightInPoints_ReturnsPositiveValue()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ float lineHeight = shaper.GetLineHeightInPoints(12);
+
+ // Assert
+ Assert.IsTrue(lineHeight > 0, "Line height should be positive");
+ Assert.IsTrue(lineHeight > 10, "Line height should be reasonable for 12pt");
+ Assert.IsTrue(lineHeight < 30, "Line height should be reasonable for 12pt");
+ }
+
+ [TestMethod]
+ public void GetFontHeightInPoints_ReturnsPositiveValue()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ float fontHeight = shaper.GetFontHeightInPoints(12);
+
+ // Assert
+ Assert.IsTrue(fontHeight > 0, "Font height should be positive");
+ Assert.IsTrue(fontHeight > 10, "Font height should be reasonable for 12pt");
+ Assert.IsTrue(fontHeight < 20, "Font height should be reasonable for 12pt");
+ }
+
+ [TestMethod]
+ public void GetLineHeight_IsGreaterThanFontHeight()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ float lineHeight = shaper.GetLineHeightInPoints(12);
+ float fontHeight = shaper.GetFontHeightInPoints(12);
+
+ // Assert
+ Assert.IsTrue(lineHeight >= fontHeight,
+ "Line height (with line gap) should be >= font height");
+ }
+
+ [TestMethod]
+ public void GetLineHeight_ScalesWithFontSize()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ float height12 = shaper.GetLineHeightInPoints(12);
+ float height24 = shaper.GetLineHeightInPoints(24);
+
+ // Assert
+ Assert.AreEqual(2.0f, height24 / height12, 0.01f,
+ "Line height should scale linearly with font size");
+ }
+
+ #endregion
+
+ #region ShapedText Properties Tests
+
+ [TestMethod]
+ public void ShapedText_GetWidthInPoints_MatchesMeasureText()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var shaped = shaper.Shape("Hello");
+ float width1 = shaped.GetWidthInPoints(12, font.HeadTable.UnitsPerEm);
+ float width2 = shaper.MeasureTextInPoints("Hello", 12);
+
+ // Assert
+ Assert.AreEqual(width1, width2, 0.01f, "Both methods should return same width");
+ }
+
+ [TestMethod]
+ public void ShapedText_GetWidthInPixels_MatchesMeasureText()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var shaped = shaper.Shape("Hello");
+ float width1 = shaped.GetWidthInPixels(12, 96, font.HeadTable.UnitsPerEm);
+ float width2 = shaper.MeasureTextInPixels("Hello", 12, 96);
+
+ // Assert
+ Assert.AreEqual(width1, width2, 0.01f, "Both methods should return same width");
+ }
+
+ #endregion
+
+ #region Edge Cases
+
+ [TestMethod]
+ public void Shape_OnlySpaces_ReturnsGlyphs()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var shaped = shaper.Shape(" ");
+
+ // Assert
+ Assert.AreEqual(3, shaped.Glyphs.Length);
+ Assert.IsTrue(shaped.TotalAdvanceWidth > 0, "Spaces should have width");
+ }
+
+ [TestMethod]
+ public void Shape_SpecialCharacters_HandlesGracefully()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var shaped = shaper.Shape("@#$%");
+
+ // Assert
+ Assert.AreEqual(4, shaped.Glyphs.Length);
+ Assert.IsTrue(shaped.TotalAdvanceWidth > 0);
+ }
+
+ [TestMethod]
+ public void Shape_Numbers_ReturnsCorrectGlyphs()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var shaped = shaper.Shape("12345");
+
+ // Assert
+ Assert.AreEqual(5, shaped.Glyphs.Length);
+ Assert.IsTrue(shaped.TotalAdvanceWidth > 0);
+ }
+
+ #endregion
+
+ #region Shaping with ligatures
+ [TestMethod]
+ public void Shape_FiLigature_CombinesTwoGlyphs()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var withLigatures = shaper.Shape("fi", ShapingOptions.Default);
+ var withoutLigatures = shaper.Shape("fi", ShapingOptions.None);
+
+ // Assert
+ Assert.IsTrue(withLigatures.Glyphs.Length < withoutLigatures.Glyphs.Length,
+ "Ligatures should combine glyphs (fi → 1 glyph instead of 2)");
+ }
+
+ [TestMethod]
+ public void Shape_Office_HasFfiLigature()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var result = shaper.Shape("office");
+
+ // Assert - "ffi" should be one ligature glyph with CharCount=3
+ bool hasFfiLigature = result.Glyphs.Any(g => g.CharCount == 3);
+ Assert.IsTrue(hasFfiLigature, "Should find ffi ligature in 'office'");
+ }
+
+ [TestMethod]
+ public void Shape_Ligature_PreservesClusterIndex()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var result = shaper.Shape("afi");
+
+ // Assert
+ // Glyph[0]: 'a' at cluster 0
+ // Glyph[1]: 'fi' ligature at cluster 1, represents 2 chars
+ Assert.AreEqual(0, result.Glyphs[0].ClusterIndex);
+ Assert.AreEqual(1, result.Glyphs[1].ClusterIndex);
+ Assert.AreEqual(2, result.Glyphs[1].CharCount);
+ }
+ #endregion
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/Integration/OpenTypeFontTextMeasurer.cs b/src/EPPlus.Fonts.OpenType/Integration/OpenTypeFontTextMeasurer.cs
new file mode 100644
index 000000000..f76d9e534
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/Integration/OpenTypeFontTextMeasurer.cs
@@ -0,0 +1,89 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ *************************************************************************************************/
+using EPPlus.Fonts.OpenType.TextShaping;
+using OfficeOpenXml.Interfaces.Drawing.Text;
+using System;
+
+namespace EPPlus.Fonts.OpenType.Integration
+{
+ ///
+ /// ITextMeasurer implementation using OpenType font shaping.
+ /// Provides accurate text measurement with ligatures and kerning support.
+ ///
+ public class OpenTypeFontTextMeasurer : ITextMeasurer
+ {
+ private readonly TextShaper _shaper;
+ private readonly OpenTypeFont _font;
+ private ShapingOptions _shapingOptions;
+
+ public OpenTypeFontTextMeasurer(OpenTypeFont font, ShapingOptions options = null)
+ {
+ _font = font ?? throw new ArgumentNullException(nameof(font));
+ _shaper = new TextShaper(font);
+ _shapingOptions = options ?? ShapingOptions.Default;
+ MeasureWrappedTextCells = true;
+ }
+
+ ///
+ /// Always valid - pure .NET implementation with no external dependencies.
+ ///
+ public bool ValidForEnvironment()
+ {
+ return true;
+ }
+
+ ///
+ /// Controls whether multi-line text (with CR/LF/CRLF) should be measured.
+ ///
+ public bool MeasureWrappedTextCells { get; set; }
+
+ ///
+ /// Measures text width and height.
+ ///
+ public TextMeasurement MeasureText(string text, MeasurementFont font)
+ {
+ if (string.IsNullOrEmpty(text))
+ {
+ return TextMeasurement.Empty;
+ }
+
+ // Check if text contains newlines
+ bool hasNewlines = text.IndexOfAny(new[] { '\r', '\n' }) >= 0;
+
+ if (hasNewlines && MeasureWrappedTextCells)
+ {
+ return MeasureMultiLineText(text, font);
+ }
+ else
+ {
+ return MeasureSingleLineText(text, font);
+ }
+ }
+
+ private TextMeasurement MeasureSingleLineText(string text, MeasurementFont font)
+ {
+ var shaped = _shaper.Shape(text, _shapingOptions);
+ float unitsPerEm = _font.HeadTable.UnitsPerEm;
+
+ float width = shaped.GetWidthInPoints(font.Size, unitsPerEm);
+ float lineHeight = _shaper.GetLineHeightInPoints(font.Size);
+ float fontHeight = _shaper.GetFontHeightInPoints(font.Size);
+
+ return new TextMeasurement(width, lineHeight)
+ {
+ FontHeight = fontHeight
+ };
+ }
+
+ private TextMeasurement MeasureMultiLineText(string text, MeasurementFont font)
+ {
+ var metrics = _shaper.MeasureLines(text, font.Size, _shapingOptions);
+
+ return new TextMeasurement(metrics.Width, metrics.Height)
+ {
+ FontHeight = metrics.FontHeight
+ };
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefFormat1.cs b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefFormat1.cs
new file mode 100644
index 000000000..27cf95aff
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefFormat1.cs
@@ -0,0 +1,53 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 10/07/2025 EPPlus Software AB EPPlus.Fonts.OpenType 1.0
+ *************************************************************************************************/
+namespace EPPlus.Fonts.OpenType.Tables.Common.Layout.ClassDef
+{
+ public class ClassDefFormat1 : ClassDefTable
+ {
+ public ushort StartGlyphID { get; set; }
+ public ushort GlyphCount { get; set; }
+ public ushort[] ClassValueArray { get; set; }
+
+ public ClassDefFormat1()
+ {
+ Format = 1;
+ }
+
+ public override int GetClass(ushort glyphId)
+ {
+ int index = glyphId - StartGlyphID;
+ if (index < 0 || index >= GlyphCount)
+ return 0;
+
+ if (ClassValueArray == null || index >= ClassValueArray.Length)
+ return 0;
+
+ return ClassValueArray[index];
+ }
+
+ internal override void SerializeBody(FontsBinaryWriter writer)
+ {
+ writer.WriteUInt16BigEndian(StartGlyphID);
+ writer.WriteUInt16BigEndian(GlyphCount);
+
+ for (int i = 0; i < GlyphCount; i++)
+ {
+ ushort v = 0;
+ if (ClassValueArray != null && i < ClassValueArray.Length)
+ v = ClassValueArray[i];
+
+ writer.WriteUInt16BigEndian(v);
+ }
+ }
+ }
+}
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefFormat2.cs b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefFormat2.cs
new file mode 100644
index 000000000..e66e94d28
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefFormat2.cs
@@ -0,0 +1,56 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 10/07/2025 EPPlus Software AB EPPlus.Fonts.OpenType 1.0
+ *************************************************************************************************/
+using System.Collections.Generic;
+
+namespace EPPlus.Fonts.OpenType.Tables.Common.Layout.ClassDef
+{
+ public class ClassDefFormat2 : ClassDefTable
+ {
+ public List ClassRangeRecords { get; set; }
+
+ public ClassDefFormat2()
+ {
+ Format = 2;
+ }
+
+ public override int GetClass(ushort glyphId)
+ {
+ if (ClassRangeRecords == null)
+ return 0;
+
+ foreach (var r in ClassRangeRecords)
+ {
+ if (glyphId >= r.StartGlyphID && glyphId <= r.EndGlyphID)
+ return r.Class;
+ }
+
+ return 0;
+ }
+
+ internal override void SerializeBody(FontsBinaryWriter writer)
+ {
+ ushort count = (ushort)(ClassRangeRecords?.Count ?? 0);
+ writer.WriteUInt16BigEndian(count);
+
+ if (ClassRangeRecords != null)
+ {
+ foreach (var r in ClassRangeRecords)
+ {
+ writer.WriteUInt16BigEndian(r.StartGlyphID);
+ writer.WriteUInt16BigEndian(r.EndGlyphID);
+ writer.WriteUInt16BigEndian(r.Class);
+ }
+ }
+ }
+ }
+}
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefTable.cs b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefTable.cs
new file mode 100644
index 000000000..704e7090f
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefTable.cs
@@ -0,0 +1,46 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 10/07/2025 EPPlus Software AB EPPlus.Fonts.OpenType 1.0
+ *************************************************************************************************/
+namespace EPPlus.Fonts.OpenType.Tables.Common.Layout.ClassDef
+{
+ ///
+ /// Base class for ClassDef subtables (Format 1 and Format 2).
+ /// Defines the common API and serialization entry point.
+ ///
+ public abstract class ClassDefTable : FontTableElement
+ {
+ ///
+ /// ClassDef format (1 or 2).
+ ///
+ public ushort Format { get; protected set; }
+
+ ///
+ /// Returns the class value for a given glyph ID.
+ ///
+ public abstract int GetClass(ushort glyphId);
+
+ ///
+ /// Writes the ClassDef table to the stream.
+ /// Subclasses implement the actual body.
+ ///
+ internal override void Serialize(FontsBinaryWriter writer)
+ {
+ writer.WriteUInt16BigEndian(Format);
+ SerializeBody(writer);
+ }
+
+ ///
+ /// Subclasses implement the format-specific serialization.
+ ///
+ internal abstract void SerializeBody(FontsBinaryWriter writer);
+ }
+}
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassRangeRecord.cs b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassRangeRecord.cs
new file mode 100644
index 000000000..e11b1b469
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassRangeRecord.cs
@@ -0,0 +1,38 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 10/07/2025 EPPlus Software AB EPPlus.Fonts.OpenType 1.0
+ *************************************************************************************************/
+using System;
+
+namespace EPPlus.Fonts.OpenType.Tables.Common.Layout.ClassDef
+{
+ ///
+ /// Represents a single ClassRangeRecord in a ClassDef Format 2 table.
+ /// Maps a continuous glyph ID range to a class value.
+ ///
+ public class ClassRangeRecord
+ {
+ ///
+ /// First glyph ID in the range (inclusive).
+ ///
+ public ushort StartGlyphID { get; set; }
+
+ ///
+ /// Last glyph ID in the range (inclusive).
+ ///
+ public ushort EndGlyphID { get; set; }
+
+ ///
+ /// Class value assigned to all glyphs in [StartGlyphID, EndGlyphID].
+ ///
+ public ushort Class { get; set; }
+ }
+}
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/IO/ClassDefTableDeserializer.cs b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/IO/ClassDefTableDeserializer.cs
new file mode 100644
index 000000000..0ab908499
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/IO/ClassDefTableDeserializer.cs
@@ -0,0 +1,104 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 16/01/2026 EPPlus Software AB ClassDef deserializer (Format 1 & 2)
+ *************************************************************************************************/
+using System.Collections.Generic;
+using System.IO;
+
+namespace EPPlus.Fonts.OpenType.Tables.Common.Layout.ClassDef.IO
+{
+ ///
+ /// Deserializes ClassDef tables (Format 1 and 2) from OpenType fonts.
+ /// Shared between GSUB and GPOS.
+ ///
+ internal class ClassDefTableDeserializer
+ {
+ private readonly FontsBinaryReader _reader;
+
+ public ClassDefTableDeserializer(FontsBinaryReader reader)
+ {
+ _reader = reader;
+ }
+
+ ///
+ /// Deserializes a ClassDef table at the given absolute offset.
+ ///
+ /// Absolute byte offset where the ClassDef table starts.
+ public ClassDefTable Deserialize(long classDefStart)
+ {
+ _reader.BaseStream.Seek(classDefStart, SeekOrigin.Begin);
+
+ ushort format = _reader.ReadUInt16BigEndian();
+
+ if (format == 1)
+ {
+ return ReadFormat1(classDefStart);
+ }
+ else if (format == 2)
+ {
+ return ReadFormat2(classDefStart);
+ }
+
+ // Okänt format – returnera null eller kasta om du vill vara strikt
+ return null;
+ }
+
+ private ClassDefTable ReadFormat1(long classDefStart)
+ {
+ // Format 1:
+ // USHORT ClassFormat (already read)
+ // USHORT StartGlyphID
+ // USHORT GlyphCount
+ // USHORT ClassValueArray[GlyphCount]
+
+ var table = new ClassDefFormat1
+ {
+ StartGlyphID = _reader.ReadUInt16BigEndian(),
+ GlyphCount = _reader.ReadUInt16BigEndian()
+ };
+
+ table.ClassValueArray = new ushort[table.GlyphCount];
+ for (int i = 0; i < table.GlyphCount; i++)
+ {
+ table.ClassValueArray[i] = _reader.ReadUInt16BigEndian();
+ }
+
+ return table;
+ }
+
+ private ClassDefTable ReadFormat2(long classDefStart)
+ {
+ // Format 2:
+ // USHORT ClassFormat (already read)
+ // USHORT ClassRangeCount
+ // ClassRangeRecord ClassRangeRecord[ClassRangeCount]
+
+ var table = new ClassDefFormat2();
+
+ ushort classRangeCount = _reader.ReadUInt16BigEndian();
+ table.ClassRangeRecords = new List(classRangeCount);
+
+ for (int i = 0; i < classRangeCount; i++)
+ {
+ var rec = new ClassRangeRecord
+ {
+ StartGlyphID = _reader.ReadUInt16BigEndian(),
+ EndGlyphID = _reader.ReadUInt16BigEndian(),
+ Class = _reader.ReadUInt16BigEndian()
+ };
+
+ table.ClassRangeRecords.Add(rec);
+ }
+
+ return table;
+ }
+ }
+}
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Gpos/Data/Lookups/LookupType2/PairPosSubTableFormat2.cs b/src/EPPlus.Fonts.OpenType/Tables/Gpos/Data/Lookups/LookupType2/PairPosSubTableFormat2.cs
new file mode 100644
index 000000000..19e9f45f0
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/Tables/Gpos/Data/Lookups/LookupType2/PairPosSubTableFormat2.cs
@@ -0,0 +1,202 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 10/07/2025 EPPlus Software AB EPPlus.Fonts.OpenType 1.0
+ *************************************************************************************************/
+using EPPlus.Fonts.OpenType.Tables.Common.Layout.ClassDef;
+
+namespace EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups.LookupType2
+{
+ ///
+ /// PairPos Format 2: Class-based kerning.
+ /// Uses ClassDef1/ClassDef2 and a class matrix.
+ ///
+ public class PairPosSubTableFormat2 : PairPosSubTable
+ {
+ ///
+ /// Class definition for first glyph (ClassDef1)
+ ///
+ public ClassDefTable ClassDef1 { get; set; }
+
+ ///
+ /// Class definition for second glyph (ClassDef2)
+ ///
+ public ClassDefTable ClassDef2 { get; set; }
+
+ ///
+ /// Number of classes in ClassDef1
+ ///
+ public ushort Class1Count { get; set; }
+
+ ///
+ /// Number of classes in ClassDef2
+ ///
+ public ushort Class2Count { get; set; }
+
+ ///
+ /// Matrix [Class1Count, Class2Count] of pair value records
+ ///
+ public PairValueRecord[,] ClassMatrix { get; set; }
+
+ public override bool TryGetPairAdjustment(
+ ushort firstGlyph,
+ ushort secondGlyph,
+ out ValueRecord value1,
+ out ValueRecord value2)
+ {
+ value1 = null;
+ value2 = null;
+
+ System.Diagnostics.Debug.WriteLine($"[Format2] Trying pair: {firstGlyph} + {secondGlyph}");
+
+ if (Coverage == null || ClassDef1 == null || ClassDef2 == null || ClassMatrix == null)
+ {
+ System.Diagnostics.Debug.WriteLine($" ✗ Missing data: Cov={Coverage != null}, CD1={ClassDef1 != null}, CD2={ClassDef2 != null}, Matrix={ClassMatrix != null}");
+ return false;
+ }
+
+ // First glyph must be in coverage
+ int coverageIndex = Coverage.GetGlyphIndex(firstGlyph);
+ System.Diagnostics.Debug.WriteLine($" Coverage index for {firstGlyph}: {coverageIndex}");
+
+ if (coverageIndex < 0)
+ {
+ System.Diagnostics.Debug.WriteLine($" ✗ First glyph {firstGlyph} not in coverage");
+ return false;
+ }
+
+ int class1 = ClassDef1.GetClass(firstGlyph);
+ int class2 = ClassDef2.GetClass(secondGlyph);
+
+ System.Diagnostics.Debug.WriteLine($" Classes: class1={class1}, class2={class2}");
+ System.Diagnostics.Debug.WriteLine($" Matrix bounds: Class1Count={Class1Count}, Class2Count={Class2Count}");
+
+ if (class1 < 0 || class2 < 0)
+ {
+ System.Diagnostics.Debug.WriteLine($" ✗ Negative class!");
+ return false;
+ }
+
+ if (class1 >= Class1Count || class2 >= Class2Count)
+ {
+ System.Diagnostics.Debug.WriteLine($" ✗ Class out of bounds!");
+ return false;
+ }
+
+ var record = ClassMatrix[class1, class2];
+
+ if (record == null)
+ {
+ System.Diagnostics.Debug.WriteLine($" ✗ Matrix[{class1},{class2}] is null");
+ return false;
+ }
+
+ System.Diagnostics.Debug.WriteLine($" Matrix[{class1},{class2}] exists:");
+ System.Diagnostics.Debug.WriteLine($" Value1: {(record.Value1 != null ? $"XAdv={record.Value1.XAdvance}" : "null")}");
+ System.Diagnostics.Debug.WriteLine($" Value2: {(record.Value2 != null ? $"XAdv={record.Value2.XAdvance}" : "null")}");
+
+ if (record.Value1 == null && record.Value2 == null)
+ {
+ System.Diagnostics.Debug.WriteLine($" ✗ Both values are null");
+ return false;
+ }
+
+ value1 = record.Value1;
+ value2 = record.Value2;
+
+ System.Diagnostics.Debug.WriteLine($" ✓ SUCCESS! Returning XAdvance={value1?.XAdvance ?? 0}");
+ return true;
+ }
+
+ internal override void Serialize(FontsBinaryWriter writer)
+ {
+ long subtableStart = writer.BaseStream.Position;
+
+ // Header
+ writer.WriteUInt16BigEndian(SubtableFormat); // 2
+
+ long coverageOffsetPos = writer.BaseStream.Position;
+ writer.WriteUInt16BigEndian(0); // Coverage offset placeholder
+
+ long classDef1OffsetPos = writer.BaseStream.Position;
+ writer.WriteUInt16BigEndian(0); // ClassDef1 offset placeholder
+
+ long classDef2OffsetPos = writer.BaseStream.Position;
+ writer.WriteUInt16BigEndian(0); // ClassDef2 offset placeholder
+
+ writer.WriteUInt16BigEndian(ValueFormat1);
+ writer.WriteUInt16BigEndian(ValueFormat2);
+
+ writer.WriteUInt16BigEndian(Class1Count);
+ writer.WriteUInt16BigEndian(Class2Count);
+
+ // Class1Record/Class2Record matrix
+ for (int i = 0; i < Class1Count; i++)
+ {
+ for (int j = 0; j < Class2Count; j++)
+ {
+ var record = ClassMatrix?[i, j];
+
+ if (record != null)
+ {
+ record.Value1?.Write(writer, ValueFormat1);
+ record.Value2?.Write(writer, ValueFormat2);
+ }
+ else
+ {
+ // Write empty value records
+ var empty = new ValueRecord();
+ empty.Write(writer, ValueFormat1);
+ empty.Write(writer, ValueFormat2);
+ }
+ }
+ }
+
+ // Coverage
+ if (Coverage != null)
+ {
+ ushort coverageOffset = (ushort)(writer.BaseStream.Position - subtableStart);
+ long resumePos = writer.BaseStream.Position;
+
+ writer.BaseStream.Seek(coverageOffsetPos, System.IO.SeekOrigin.Begin);
+ writer.WriteUInt16BigEndian(coverageOffset);
+ writer.BaseStream.Seek(resumePos, System.IO.SeekOrigin.Begin);
+
+ Coverage.Serialize(writer);
+ }
+
+ // ClassDef1
+ if (ClassDef1 != null)
+ {
+ ushort classDef1Offset = (ushort)(writer.BaseStream.Position - subtableStart);
+ long resumePos = writer.BaseStream.Position;
+
+ writer.BaseStream.Seek(classDef1OffsetPos, System.IO.SeekOrigin.Begin);
+ writer.WriteUInt16BigEndian(classDef1Offset);
+ writer.BaseStream.Seek(resumePos, System.IO.SeekOrigin.Begin);
+
+ ClassDef1.Serialize(writer);
+ }
+
+ // ClassDef2
+ if (ClassDef2 != null)
+ {
+ ushort classDef2Offset = (ushort)(writer.BaseStream.Position - subtableStart);
+ long resumePos = writer.BaseStream.Position;
+
+ writer.BaseStream.Seek(classDef2OffsetPos, System.IO.SeekOrigin.Begin);
+ writer.WriteUInt16BigEndian(classDef2Offset);
+ writer.BaseStream.Seek(resumePos, System.IO.SeekOrigin.Begin);
+
+ ClassDef2.Serialize(writer);
+ }
+ }
+ }
+}
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Gpos/Data/Lookups/LookupType2/PairPosSubTableFormat2Deserializer.cs b/src/EPPlus.Fonts.OpenType/Tables/Gpos/Data/Lookups/LookupType2/PairPosSubTableFormat2Deserializer.cs
new file mode 100644
index 000000000..6a2d0689e
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/Tables/Gpos/Data/Lookups/LookupType2/PairPosSubTableFormat2Deserializer.cs
@@ -0,0 +1,109 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 10/07/2025 EPPlus Software AB EPPlus.Fonts.OpenType 1.0
+ *************************************************************************************************/
+using EPPlus.Fonts.OpenType.Tables.Common.Layout.ClassDef.IO;
+using EPPlus.Fonts.OpenType.Tables.Common.Layout.Coverage.IO;
+using System.IO;
+
+namespace EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups.LookupType2
+{
+ ///
+ /// Deserializes PairPos Format 2 subtables (class-based kerning)
+ ///
+ internal class PairPosSubTableFormat2Deserializer
+ {
+ private readonly FontsBinaryReader _reader;
+
+ public PairPosSubTableFormat2Deserializer(FontsBinaryReader reader)
+ {
+ _reader = reader;
+ }
+
+ public PairPosSubTableFormat2 Deserialize(long subtableStart)
+ {
+ _reader.BaseStream.Seek(subtableStart, SeekOrigin.Begin);
+
+ var table = new PairPosSubTableFormat2();
+ // Header
+ table.SubtableFormat = _reader.ReadUInt16BigEndian(); // Should be 2
+
+ ushort coverageOffset = _reader.ReadUInt16BigEndian();
+ table.ValueFormat1 = _reader.ReadUInt16BigEndian();
+ table.ValueFormat2 = _reader.ReadUInt16BigEndian();
+
+ ushort classDef1Offset = _reader.ReadUInt16BigEndian();
+ ushort classDef2Offset = _reader.ReadUInt16BigEndian();
+
+ table.Class1Count = _reader.ReadUInt16BigEndian();
+ table.Class2Count = _reader.ReadUInt16BigEndian();
+
+ // Read class matrix
+ table.ClassMatrix = new PairValueRecord[table.Class1Count, table.Class2Count];
+
+ for (int i = 0; i < table.Class1Count; i++)
+ {
+ for (int j = 0; j < table.Class2Count; j++)
+ {
+ var value1 = ValueRecord.Read(_reader, table.ValueFormat1);
+ var value2 = ValueRecord.Read(_reader, table.ValueFormat2);
+
+ table.ClassMatrix[i, j] = new PairValueRecord
+ {
+ Value1 = value1,
+ Value2 = value2
+ };
+ }
+ }
+
+ // Coverage
+ if (coverageOffset > 0)
+ {
+ long coveragePos = subtableStart + coverageOffset;
+ _reader.BaseStream.Seek(coveragePos, SeekOrigin.Begin);
+
+ ushort coverageFormat = _reader.ReadUInt16BigEndian();
+ if (coverageFormat == 1)
+ {
+ table.Coverage = new CoverageTableFormat1Deserializer(_reader)
+ .Deserialize(coveragePos);
+ }
+ else if (coverageFormat == 2)
+ {
+ table.Coverage = new CoverageTableFormat2Deserializer(_reader)
+ .Deserialize(coveragePos);
+ }
+ }
+
+ // ClassDef1
+ if (classDef1Offset > 0)
+ {
+ long classDef1Pos = subtableStart + classDef1Offset;
+ _reader.BaseStream.Seek(classDef1Pos, SeekOrigin.Begin);
+
+ table.ClassDef1 = new ClassDefTableDeserializer(_reader)
+ .Deserialize(classDef1Pos);
+ }
+
+ // ClassDef2
+ if (classDef2Offset > 0)
+ {
+ long classDef2Pos = subtableStart + classDef2Offset;
+ _reader.BaseStream.Seek(classDef2Pos, SeekOrigin.Begin);
+
+ table.ClassDef2 = new ClassDefTableDeserializer(_reader)
+ .Deserialize(classDef2Pos);
+ }
+
+ return table;
+ }
+ }
+}
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Gpos/GposTableLoader.cs b/src/EPPlus.Fonts.OpenType/Tables/Gpos/GposTableLoader.cs
index 92326cd12..aedbb8f22 100644
--- a/src/EPPlus.Fonts.OpenType/Tables/Gpos/GposTableLoader.cs
+++ b/src/EPPlus.Fonts.OpenType/Tables/Gpos/GposTableLoader.cs
@@ -212,8 +212,7 @@ private FontTableElement ReadPairPosSubTable(FontsBinaryReader reader, long subt
}
else if (posFormat == 2)
{
- // TODO: Implement Format 2 (class-based pairs)
- return null;
+ return ReadPairPosFormat2(reader, subtableStart);
}
else
{
@@ -228,6 +227,13 @@ private PairPosSubTableFormat1 ReadPairPosFormat1(FontsBinaryReader reader, long
return deserializer.Deserialize(subtableStart);
}
+ private PairPosSubTableFormat2 ReadPairPosFormat2(FontsBinaryReader reader, long subtableStart)
+ {
+ var deserializer = new PairPosSubTableFormat2Deserializer(reader);
+ return deserializer.Deserialize(subtableStart);
+ }
+
+
private FontTableElement ReadSinglePosSubTable(FontsBinaryReader reader, long subtableStart)
{
// Read format to determine which deserializer to use
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Gpos/Handlers/PairPosHandler.cs b/src/EPPlus.Fonts.OpenType/Tables/Gpos/Handlers/PairPosHandler.cs
index b2cc1c4ba..7a6e5794b 100644
--- a/src/EPPlus.Fonts.OpenType/Tables/Gpos/Handlers/PairPosHandler.cs
+++ b/src/EPPlus.Fonts.OpenType/Tables/Gpos/Handlers/PairPosHandler.cs
@@ -64,11 +64,10 @@ public LookupTable Rewrite(FontSubsettingContext context, LookupTable lookup)
{
rewritten = RewriteFormat1(context, format1);
}
- // Format 2 not implemented yet
- // else if (subtable is PairPosSubTableFormat2 format2)
- // {
- // rewritten = RewriteFormat2(context, format2);
- // }
+ else if (subtable is PairPosSubTableFormat2 format2) // ← Aktivera!
+ {
+ rewritten = RewriteFormat2(context, format2);
+ }
if (rewritten != null)
{
@@ -152,6 +151,129 @@ private PairPosSubTableFormat1 RewriteFormat1(FontSubsettingContext context, Pai
return rewritten;
}
+ ///
+ /// Rewrites a PairPos Format 2 subtable by expanding class-based kerning to Format 1.
+ /// This simplifies subsetting and ensures compatibility.
+ ///
+ private PairPosSubTableFormat1 RewriteFormat2(FontSubsettingContext context, PairPosSubTableFormat2 original)
+ {
+ // Strategy: Expand class matrix to individual pairs (Format 1)
+ // This is simpler than subsetting the class definitions and matrix
+
+ // Build map of first glyphs that are both:
+ // 1. In the original coverage
+ // 2. In our subset
+ var firstGlyphMappings = new List();
+
+ for (ushort oldGlyphId = 0; oldGlyphId < 65535; oldGlyphId++)
+ {
+ // Must be in coverage
+ int coverageIndex = original.Coverage.GetGlyphIndex(oldGlyphId);
+ if (coverageIndex < 0)
+ continue;
+
+ // Must be in subset
+ if (!context.OldToNewGlyphId.TryGetValue(oldGlyphId, out ushort newGlyphId))
+ continue;
+
+ firstGlyphMappings.Add(new GlyphMapping
+ {
+ OldGlyphId = oldGlyphId,
+ NewGlyphId = newGlyphId,
+ OldCoverageIndex = -1 // Not used for Format 2
+ });
+ }
+
+ if (firstGlyphMappings.Count == 0)
+ return null;
+
+ // Sort by NEW glyph ID for coverage
+ firstGlyphMappings.Sort((a, b) => a.NewGlyphId.CompareTo(b.NewGlyphId));
+
+ // Build PairSets by expanding class matrix
+ var newPairSets = new List();
+ var newCoverageGlyphs = new List();
+
+ foreach (var firstMapping in firstGlyphMappings)
+ {
+ // Get class for first glyph
+ int class1 = original.ClassDef1.GetClass(firstMapping.OldGlyphId);
+ if (class1 < 0 || class1 >= original.Class1Count)
+ continue;
+
+ // Collect all pairs for this first glyph
+ var pairRecords = new List();
+
+ // Check all possible second glyphs in our subset
+ foreach (var oldSecondGlyph in context.IncludedGlyphs)
+ {
+ // Skip if same glyph
+ if (oldSecondGlyph == firstMapping.OldGlyphId)
+ continue;
+
+ // Get class for second glyph
+ int class2 = original.ClassDef2.GetClass(oldSecondGlyph);
+ if (class2 < 0 || class2 >= original.Class2Count)
+ continue;
+
+ // Look up in class matrix
+ var record = original.ClassMatrix[class1, class2];
+ if (record == null)
+ continue;
+
+ // Skip if no actual adjustment
+ bool hasValue1 = record.Value1 != null && record.Value1.XAdvance != 0;
+ bool hasValue2 = record.Value2 != null && record.Value2.XAdvance != 0;
+
+ if (!hasValue1 && !hasValue2)
+ continue;
+
+ // Get remapped second glyph ID
+ if (!context.OldToNewGlyphId.TryGetValue(oldSecondGlyph, out ushort newSecondGlyph))
+ continue;
+
+ // Add pair with remapped ID
+ pairRecords.Add(new PairValueRecord
+ {
+ SecondGlyph = newSecondGlyph,
+ Value1 = record.Value1,
+ Value2 = record.Value2
+ });
+ }
+
+ // Only include if we found pairs
+ if (pairRecords.Count > 0)
+ {
+ newCoverageGlyphs.Add(firstMapping.NewGlyphId);
+ newPairSets.Add(new PairSet
+ {
+ PairValueRecords = pairRecords
+ });
+ }
+ }
+
+ if (newPairSets.Count == 0)
+ return null;
+
+ // Create new coverage
+ var newCoverage = new CoverageTableFormat1
+ {
+ CoverageFormat = 1,
+ GlyphCount = (ushort)newCoverageGlyphs.Count,
+ GlyphArray = newCoverageGlyphs.ToArray()
+ };
+
+ // Return as Format 1 (expanded from class-based)
+ return new PairPosSubTableFormat1
+ {
+ SubtableFormat = 1,
+ ValueFormat1 = original.ValueFormat1,
+ ValueFormat2 = original.ValueFormat2,
+ Coverage = newCoverage,
+ PairSets = newPairSets
+ };
+ }
+
///
/// Filters a PairSet to only include pairs where second glyph is in subset.
/// Remaps second glyph IDs.
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Gsub/IO/ChainingContextualDeserializer.cs b/src/EPPlus.Fonts.OpenType/Tables/Gsub/IO/ChainingContextualDeserializer.cs
index a7d93ac11..38936ed8a 100644
--- a/src/EPPlus.Fonts.OpenType/Tables/Gsub/IO/ChainingContextualDeserializer.cs
+++ b/src/EPPlus.Fonts.OpenType/Tables/Gsub/IO/ChainingContextualDeserializer.cs
@@ -21,6 +21,9 @@ namespace EPPlus.Fonts.OpenType.Tables.Gsub.IO
{
///
/// Deserializes Chaining Contextual Substitution subtables from the GSUB table.
+ /// Currently supports Format 3 (Coverage-based context) only.
+ /// Format 1 (Simple context) and Format 2 (Class-based context) are not implemented.
+ /// Format 3 is the most common format in modern fonts and sufficient for most use cases.
///
internal class ChainingContextualDeserializer
{
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/KerningProvider.cs b/src/EPPlus.Fonts.OpenType/TextShaping/KerningProvider.cs
index 47a790bed..14a34e422 100644
--- a/src/EPPlus.Fonts.OpenType/TextShaping/KerningProvider.cs
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/KerningProvider.cs
@@ -1,16 +1,4 @@
-/*************************************************************************************************
- Required Notice: Copyright (C) EPPlus Software AB.
- This software is licensed under PolyForm Noncommercial License 1.0.0
- and may only be used for noncommercial purposes
- https://polyformproject.org/licenses/noncommercial/1.0.0/
-
- A commercial license to use this software can be purchased at https://epplussoftware.com
- *************************************************************************************************
- Date Author Change
- *************************************************************************************************
- 01/15/2025 EPPlus Software AB Initial implementation
- *************************************************************************************************/
-using EPPlus.Fonts.OpenType.Tables.Gpos;
+using EPPlus.Fonts.OpenType.Tables.Gpos;
using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups;
using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups.LookupType2;
using EPPlus.Fonts.OpenType.Tables.Kern;
@@ -21,6 +9,7 @@ namespace EPPlus.Fonts.OpenType.TextShaping
///
/// Provides kerning information from either GPOS (modern) or kern table (legacy).
/// Handles caching and fallback logic.
+ /// Supports both PairPos Format 1 and Format 2.
///
internal class KerningProvider
{
@@ -28,7 +17,7 @@ internal class KerningProvider
private readonly Dictionary _cache;
private readonly bool _hasGpos;
private readonly bool _hasKern;
- private PairPosSubTableFormat1 _gposKerningSubtable;
+ private List _gposKerningSubtables;
public KerningProvider(OpenTypeFont font)
{
@@ -37,20 +26,13 @@ public KerningProvider(OpenTypeFont font)
_hasGpos = font.GposTable != null;
_hasKern = font.KernTable != null;
- // Pre-locate GPOS kerning subtable if available
+ // Pre-locate ALL GPOS kerning subtables
if (_hasGpos)
{
- _gposKerningSubtable = FindGposKerningSubtable();
+ _gposKerningSubtables = FindAllGposKerningSubtables();
}
}
- ///
- /// Gets kerning value for a glyph pair.
- /// Returns 0 if no kerning is defined.
- ///
- /// Left glyph ID
- /// Right glyph ID
- /// Kerning adjustment in font units (negative = closer)
public short GetKerning(ushort leftGlyph, ushort rightGlyph)
{
// Check cache first
@@ -71,10 +53,6 @@ public short GetKerning(ushort leftGlyph, ushort rightGlyph)
return kernValue;
}
- ///
- /// Clears the kerning cache.
- /// Call this if you need to free memory.
- ///
public void ClearCache()
{
_cache.Clear();
@@ -85,7 +63,7 @@ public void ClearCache()
private short LookupKerning(ushort leftGlyph, ushort rightGlyph)
{
// Try GPOS first (modern, preferred)
- if (_hasGpos && _gposKerningSubtable != null)
+ if (_hasGpos && _gposKerningSubtables != null && _gposKerningSubtables.Count > 0)
{
short gposKern = GetGposKerning(leftGlyph, rightGlyph);
if (gposKern != 0)
@@ -105,14 +83,21 @@ private short LookupKerning(ushort leftGlyph, ushort rightGlyph)
private short GetGposKerning(ushort leftGlyph, ushort rightGlyph)
{
- if (_gposKerningSubtable == null)
+ if (_gposKerningSubtables == null || _gposKerningSubtables.Count == 0)
return 0;
- ValueRecord value1, value2;
- if (_gposKerningSubtable.TryGetPairAdjustment(leftGlyph, rightGlyph, out value1, out value2))
+ // Try each subtable until we find a match
+ // This handles fonts with multiple subtables (Format1 + Format2)
+ foreach (var subtable in _gposKerningSubtables)
{
- // Kerning is typically in value1.XAdvance
- return value1.XAdvance;
+ ValueRecord value1, value2;
+ if (subtable.TryGetPairAdjustment(leftGlyph, rightGlyph,
+ out value1, out value2))
+ {
+ // Kerning is typically in value1.XAdvance
+ if (value1 != null && value1.XAdvance != 0)
+ return value1.XAdvance;
+ }
}
return 0;
@@ -124,10 +109,8 @@ private short GetLegacyKerning(ushort leftGlyph, ushort rightGlyph)
if (kernTable == null || kernTable.SubTables == null || kernTable.SubTables.Count == 0)
return 0;
- // Iterate through subtables
foreach (var subtable in kernTable.SubTables)
{
- // Only support Format 0 (horizontal kerning)
if (subtable.coverage.Format == 0 && subtable.Format0Subtable != null)
{
short kernValue = GetKerningFromFormat0(subtable.Format0Subtable, leftGlyph, rightGlyph);
@@ -146,8 +129,6 @@ private short GetKerningFromFormat0(KernSubTableFormat0 format0, ushort leftGlyp
if (format0.Pairs == null)
return 0;
- // Linear search through kerning pairs
- // Note: Could be optimized with binary search if pairs are sorted
foreach (var pair in format0.Pairs)
{
if (pair.left == leftGlyph && pair.right == rightGlyph)
@@ -159,10 +140,13 @@ private short GetKerningFromFormat0(KernSubTableFormat0 format0, ushort leftGlyp
return 0;
}
- private PairPosSubTableFormat1 FindGposKerningSubtable()
+ private List FindAllGposKerningSubtables()
{
+ var subtables = new List();
var gpos = _font.GposTable;
- if (gpos == null) return null;
+
+ if (gpos == null)
+ return subtables;
// Find "kern" feature
foreach (var featureRecord in gpos.FeatureList.FeatureRecords)
@@ -182,13 +166,12 @@ private PairPosSubTableFormat1 FindGposKerningSubtable()
// We want PairPos (Type 2)
if (lookup.LookupType == 2)
{
- // Return first PairPos Format 1 subtable
+ // Collect ALL PairPos subtables (Format 1 and/or Format 2)
foreach (var subtable in lookup.SubTables)
{
- var pairPos = subtable as PairPosSubTableFormat1;
- if (pairPos != null)
+ if (subtable is PairPosSubTable pairPos)
{
- return pairPos;
+ subtables.Add(pairPos);
}
}
}
@@ -196,12 +179,11 @@ private PairPosSubTableFormat1 FindGposKerningSubtable()
}
}
- return null;
+ return subtables;
}
private static ulong MakeCacheKey(ushort leftGlyph, ushort rightGlyph)
{
- // Combine two ushorts into one ulong for fast dictionary lookup
return ((ulong)leftGlyph << 16) | rightGlyph;
}
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/LigatureProcessor.cs b/src/EPPlus.Fonts.OpenType/TextShaping/LigatureProcessor.cs
new file mode 100644
index 000000000..2e4067b4a
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/LigatureProcessor.cs
@@ -0,0 +1,208 @@
+using EPPlus.Fonts.OpenType.Tables.Common.Layout.Lookups;
+using EPPlus.Fonts.OpenType.Tables.Gsub;
+using EPPlus.Fonts.OpenType.Tables.Gsub.Data.Lookups;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using static System.Net.Mime.MediaTypeNames;
+
+namespace EPPlus.Fonts.OpenType.TextShaping
+{
+ internal class LigatureProcessor
+ {
+ public LigatureProcessor(OpenTypeFont font)
+ {
+ _font = font;
+ }
+
+ private readonly OpenTypeFont _font;
+
+ ///
+ /// Applies standard ligature substitutions (fi, ff, ffi, ffl, etc.).
+ /// Processes glyphs left-to-right, replacing sequences with ligature glyphs.
+ ///
+ internal List ApplyLigatures(List glyphs)
+ {
+ var gsub = _font.GsubTable;
+ if (gsub == null)
+ return glyphs;
+
+ // Find "liga" feature
+ var ligaLookups = FindLookupsForFeature(gsub, "liga");
+ if (ligaLookups.Count == 0)
+ return glyphs;
+
+ // Apply each lookup in order
+ foreach (var lookup in ligaLookups)
+ {
+ glyphs = ApplyLigatureLookup(glyphs, lookup);
+ }
+
+ return glyphs;
+ }
+
+ ///
+ /// Finds all lookups associated with a feature tag.
+ ///
+ private List FindLookupsForFeature(GsubTable gsub, string featureTag)
+ {
+ var lookups = new List();
+
+ foreach (var featureRecord in gsub.FeatureList.FeatureRecords)
+ {
+ if (featureRecord.FeatureTag.Value == featureTag)
+ {
+ var feature = featureRecord.FeatureTable;
+
+ foreach (var lookupIndex in feature.LookupListIndices)
+ {
+ if (lookupIndex < gsub.LookupList.Lookups.Count)
+ {
+ lookups.Add(gsub.LookupList.Lookups[lookupIndex]);
+ }
+ }
+ }
+ }
+
+ return lookups;
+ }
+
+ ///
+ /// Applies a single ligature lookup to the glyph sequence.
+ /// Processes left-to-right, replacing matching sequences with ligatures.
+ ///
+ private List ApplyLigatureLookup(List glyphs, LookupTable lookup)
+ {
+ if (lookup.LookupType != 4) // Must be Ligature Substitution
+ return glyphs;
+
+ var result = new List();
+ int i = 0;
+
+ while (i < glyphs.Count)
+ {
+ bool substituted = false;
+
+ // Try each subtable
+ foreach (var subtable in lookup.SubTables)
+ {
+ if (subtable is LigatureSubstSubTable ligSubtable)
+ {
+ // Try to match ligature starting at position i
+ if (TryApplyLigature(glyphs, i, ligSubtable, out var ligatureGlyph, out int componentsConsumed))
+ {
+ result.Add(ligatureGlyph);
+ i += componentsConsumed;
+ substituted = true;
+ break; // Found a match, move to next position
+ }
+ }
+ }
+
+ if (!substituted)
+ {
+ // No ligature found, keep original glyph
+ result.Add(glyphs[i]);
+ i++;
+ }
+ }
+
+ return result;
+ }
+
+ ///
+ /// Attempts to find and apply a ligature substitution starting at the given position.
+ ///
+ private bool TryApplyLigature(
+ List glyphs,
+ int startIndex,
+ LigatureSubstSubTable subtable,
+ out ShapedGlyph ligatureGlyph,
+ out int componentsConsumed)
+ {
+ ligatureGlyph = null;
+ componentsConsumed = 0;
+
+ if (startIndex >= glyphs.Count)
+ return false;
+
+ ushort firstGlyph = glyphs[startIndex].GlyphId;
+
+ // Check if first glyph is in coverage
+ int coverageIndex = subtable.Coverage.GetGlyphIndex(firstGlyph);
+ if (coverageIndex < 0)
+ return false;
+
+ // LigatureSets is a Dictionary
+ // Key is the GLYPH ID, not coverage index!
+ if (!subtable.LigatureSets.TryGetValue(firstGlyph, out var ligatureSet))
+ return false;
+
+ if (ligatureSet?.Ligatures == null)
+ return false;
+
+ // Try each ligature in the set
+ foreach (var ligature in ligatureSet.Ligatures)
+ {
+ int componentCount = 1 + (ligature.Components?.Length ?? 0);
+
+ // Check if we have enough glyphs remaining
+ if (startIndex + componentCount > glyphs.Count)
+ continue;
+
+ // Check if all component glyphs match
+ bool matches = true;
+
+ if (ligature.Components != null)
+ {
+ for (int j = 0; j < ligature.Components.Length; j++)
+ {
+ if (glyphs[startIndex + 1 + j].GlyphId != ligature.Components[j])
+ {
+ matches = false;
+ break;
+ }
+ }
+ }
+
+ if (matches)
+ {
+ // Found a match! Create ligature glyph
+ ligatureGlyph = CreateLigatureGlyph(glyphs, startIndex, componentCount, ligature.LigatureGlyph);
+ componentsConsumed = componentCount;
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ ///
+ /// Creates a new shaped glyph for a ligature, combining metrics from components.
+ ///
+ private ShapedGlyph CreateLigatureGlyph(
+ List glyphs,
+ int startIndex,
+ int componentCount,
+ ushort ligatureGlyphId)
+ {
+ // Get advance width for ligature glyph
+ int advanceWidth = _font.HmtxTable.GetAdvanceWidth(ligatureGlyphId);
+
+ // Preserve cluster index from first component
+ int clusterIndex = glyphs[startIndex].ClusterIndex;
+
+ return new ShapedGlyph
+ {
+ GlyphId = ligatureGlyphId,
+ XAdvance = advanceWidth,
+ YAdvance = 0,
+ XOffset = 0,
+ YOffset = 0,
+ ClusterIndex = clusterIndex,
+ CharCount = componentCount // Ligature represents multiple characters
+ };
+ }
+ }
+}
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/MultiLineMetrics.cs b/src/EPPlus.Fonts.OpenType/TextShaping/MultiLineMetrics.cs
new file mode 100644
index 000000000..73b544062
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/MultiLineMetrics.cs
@@ -0,0 +1,46 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/15/2025 EPPlus Software AB Initial implementation
+ *************************************************************************************************/
+
+namespace EPPlus.Fonts.OpenType.TextShaping
+{
+ ///
+ /// Metrics for multi-line text measurement
+ ///
+ public struct MultiLineMetrics
+ {
+ ///
+ /// Maximum width of all lines
+ ///
+ public float Width { get; set; }
+
+ ///
+ /// Total height (line count × line height)
+ ///
+ public float Height { get; set; }
+
+ ///
+ /// Font height without line spacing (ascent + descent)
+ ///
+ public float FontHeight { get; set; }
+
+ ///
+ /// Number of lines
+ ///
+ public int LineCount { get; set; }
+
+ ///
+ /// Height of a single line (ascent + descent + line gap)
+ ///
+ public float LineHeight { get; set; }
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/ShapedGlyph.cs b/src/EPPlus.Fonts.OpenType/TextShaping/ShapedGlyph.cs
index 0e55c54f3..40e81f8d7 100644
--- a/src/EPPlus.Fonts.OpenType/TextShaping/ShapedGlyph.cs
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/ShapedGlyph.cs
@@ -17,8 +17,23 @@ namespace EPPlus.Fonts.OpenType.TextShaping
/// Represents a shaped glyph with positioning information.
/// All measurements are in font units (not PDF points or pixels).
///
- public struct ShapedGlyph
+ public class ShapedGlyph
{
+ public ShapedGlyph()
+ {
+
+ }
+ public ShapedGlyph(ushort glyphId, int xAdvance)
+ {
+ GlyphId = glyphId;
+ XAdvance = xAdvance;
+ YAdvance = 0;
+ XOffset = 0;
+ YOffset = 0;
+ ClusterIndex = 0;
+ CharCount = 1;
+ }
+
///
/// The glyph ID in the font.
///
@@ -60,16 +75,5 @@ public struct ShapedGlyph
/// 1 for normal glyphs, 2+ for ligatures (e.g., "fi" → 1 glyph, 2 chars).
///
public int CharCount { get; set; }
-
- public ShapedGlyph(ushort glyphId, int xAdvance)
- {
- GlyphId = glyphId;
- XAdvance = xAdvance;
- YAdvance = 0;
- XOffset = 0;
- YOffset = 0;
- ClusterIndex = 0;
- CharCount = 1;
- }
}
}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs b/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs
index dc5f27d56..a8b6b3bc0 100644
--- a/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs
@@ -10,32 +10,26 @@ Date Author Change
*************************************************************************************************
01/15/2025 EPPlus Software AB Initial implementation
*************************************************************************************************/
-using EPPlus.Fonts.OpenType.Tables.Cmap;
-using EPPlus.Fonts.OpenType.Tables.Hmtx;
using System;
using System.Collections.Generic;
namespace EPPlus.Fonts.OpenType.TextShaping
{
- ///
- /// Text shaping engine that converts text strings to positioned glyphs.
- /// Handles character-to-glyph mapping, GSUB substitutions, and GPOS positioning.
- ///
public class TextShaper
{
private readonly OpenTypeFont _font;
private readonly KerningProvider _kerningProvider;
+ private readonly LigatureProcessor _ligatureProcessor;
- ///
- /// Creates a new text shaper for the specified font.
- ///
- /// The OpenType font to use for shaping
public TextShaper(OpenTypeFont font)
{
_font = font ?? throw new ArgumentNullException(nameof(font));
_kerningProvider = new KerningProvider(font);
+ _ligatureProcessor = new LigatureProcessor(font);
}
+ #region Single-line Shaping
+
///
/// Shape text using default options (ligatures + kerning).
///
@@ -48,6 +42,8 @@ public ShapedText Shape(string text)
///
/// Shape text with specified options.
+ /// Note: Newline characters (\n, \r, \r\n) are treated as regular characters.
+ /// For multi-line text, use ShapeLines() method instead.
///
/// Text to shape
/// Shaping options
@@ -91,6 +87,8 @@ public ShapedText Shape(string text, ShapingOptions options)
};
}
+ #endregion
+
#region Phase 1: Character to Glyph Mapping
///
@@ -147,22 +145,12 @@ private List ApplyGsubSubstitutions(List glyphs, Shapi
if (options.GsubFeatures != null && options.GsubFeatures.Contains("liga"))
{
- glyphs = ApplyLigatures(glyphs);
+ glyphs = _ligatureProcessor.ApplyLigatures(glyphs);
}
return glyphs;
}
- ///
- /// Applies standard ligature substitutions (fi, ff, ffi, etc.).
- ///
- private List ApplyLigatures(List glyphs)
- {
- // TODO: Implement ligature lookup
- // For now, return unchanged
- return glyphs;
- }
-
#endregion
#region Phase 3: Positioning
@@ -212,9 +200,6 @@ private void ApplyKerning(List glyphs)
///
/// Measures the width of text in font units.
///
- /// Text to measure
- /// Shaping options
- /// Width in font units
public int MeasureText(string text, ShapingOptions options = null)
{
var shaped = Shape(text, options);
@@ -224,10 +209,6 @@ public int MeasureText(string text, ShapingOptions options = null)
///
/// Measures the width of text in PDF points.
///
- /// Text to measure
- /// Font size in points
- /// Shaping options
- /// Width in PDF points
public float MeasureTextInPoints(string text, float fontSize, ShapingOptions options = null)
{
var shaped = Shape(text, options);
@@ -238,11 +219,6 @@ public float MeasureTextInPoints(string text, float fontSize, ShapingOptions opt
///
/// Measures the width of text in pixels.
///
- /// Text to measure
- /// Font size in points
- /// Screen DPI (typically 96)
- /// Shaping options
- /// Width in pixels
public float MeasureTextInPixels(string text, float fontSize, float dpi, ShapingOptions options = null)
{
var shaped = Shape(text, options);
@@ -251,5 +227,88 @@ public float MeasureTextInPixels(string text, float fontSize, float dpi, Shaping
}
#endregion
+
+ #region Multi-line Support
+
+ ///
+ /// Shape multi-line text (handles \n, \r, \r\n).
+ /// Returns one ShapedText per line.
+ ///
+ public ShapedText[] ShapeLines(string text, ShapingOptions options = null)
+ {
+ if (string.IsNullOrEmpty(text))
+ {
+ return new ShapedText[0];
+ }
+
+ var lines = text.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
+ var result = new ShapedText[lines.Length];
+
+ for (int i = 0; i < lines.Length; i++)
+ {
+ result[i] = Shape(lines[i], options);
+ }
+
+ return result;
+ }
+
+ ///
+ /// Measure multi-line text and return bounding box.
+ ///
+ public MultiLineMetrics MeasureLines(string text, float fontSize, ShapingOptions options = null)
+ {
+ var shapedLines = ShapeLines(text, options);
+ float unitsPerEm = _font.HeadTable.UnitsPerEm;
+
+ float maxWidth = 0;
+ foreach (var line in shapedLines)
+ {
+ float lineWidth = line.GetWidthInPoints(fontSize, unitsPerEm);
+ maxWidth = Math.Max(maxWidth, lineWidth);
+ }
+
+ float lineHeight = GetLineHeightInPoints(fontSize);
+ float fontHeight = GetFontHeightInPoints(fontSize);
+ float totalHeight = shapedLines.Length * lineHeight;
+
+ return new MultiLineMetrics
+ {
+ Width = maxWidth,
+ Height = totalHeight,
+ FontHeight = fontHeight,
+ LineCount = shapedLines.Length,
+ LineHeight = lineHeight
+ };
+ }
+
+ ///
+ /// Get line height (ascent + descent + line gap) in points.
+ ///
+ public float GetLineHeightInPoints(float fontSize)
+ {
+ var hhea = _font.HheaTable;
+ float unitsPerEm = _font.HeadTable.UnitsPerEm;
+
+ // ascent is positive, descender is negative
+ int lineHeightUnits = hhea.ascender - hhea.descender + hhea.lineGap;
+
+ return (lineHeightUnits / unitsPerEm) * fontSize;
+ }
+
+ ///
+ /// Get font height (ascent + descent only, no line gap) in points.
+ ///
+ public float GetFontHeightInPoints(float fontSize)
+ {
+ var hhea = _font.HheaTable;
+ float unitsPerEm = _font.HeadTable.UnitsPerEm;
+
+ // ascent is positive, descender is negative
+ int fontHeightUnits = hhea.ascender - hhea.descender;
+
+ return (fontHeightUnits / unitsPerEm) * fontSize;
+ }
+
+ #endregion
}
}
\ No newline at end of file
From 498abad57ffa7b99ac9d67ed3420f8f4fa11f96a Mon Sep 17 00:00:00 2001
From: swmal <897655+swmal@users.noreply.github.com>
Date: Mon, 19 Jan 2026 10:26:37 +0100
Subject: [PATCH 04/18] Performance improvements for TextShaping
---
.../EPPlus.Fonts.OpenType.csproj | 3 +
.../Common/Layout/ClassDef/ClassDefFormat2.cs | 26 ++-
.../LookupType2/PairPosSubTableFormat1.cs | 30 ++-
.../TextShaping/GsubShaper.cs | 11 -
.../Kerning/GposKerningProvider.cs | 96 +++++++++
.../TextShaping/Kerning/KerningCache.cs | 61 ++++++
.../TextShaping/Kerning/KerningProvider.cs | 76 +++++++
.../Kerning/LegacyKerningProvider.cs | 85 ++++++++
.../TextShaping/KerningProvider.cs | 192 ------------------
.../{ => Ligatures}/LigatureProcessor.cs | 20 +-
.../TextShaping/ShapedGlyph.cs | 3 +
.../TextShaping/ShapedText.cs | 2 +
.../TextShaping/ShapingCache.cs | 11 -
.../TextShaping/TextShaper.cs | 2 +
14 files changed, 385 insertions(+), 233 deletions(-)
delete mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/GsubShaper.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/Kerning/GposKerningProvider.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/Kerning/KerningCache.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/Kerning/KerningProvider.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/Kerning/LegacyKerningProvider.cs
delete mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/KerningProvider.cs
rename src/EPPlus.Fonts.OpenType/TextShaping/{ => Ligatures}/LigatureProcessor.cs (87%)
delete mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/ShapingCache.cs
diff --git a/src/EPPlus.Fonts.OpenType/EPPlus.Fonts.OpenType.csproj b/src/EPPlus.Fonts.OpenType/EPPlus.Fonts.OpenType.csproj
index a5e8e4ec2..27eb3df10 100644
--- a/src/EPPlus.Fonts.OpenType/EPPlus.Fonts.OpenType.csproj
+++ b/src/EPPlus.Fonts.OpenType/EPPlus.Fonts.OpenType.csproj
@@ -77,4 +77,7 @@
+
+
+
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefFormat2.cs b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefFormat2.cs
index e66e94d28..95992f245 100644
--- a/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefFormat2.cs
+++ b/src/EPPlus.Fonts.OpenType/Tables/Common/Layout/ClassDef/ClassDefFormat2.cs
@@ -25,16 +25,32 @@ public ClassDefFormat2()
public override int GetClass(ushort glyphId)
{
- if (ClassRangeRecords == null)
+ if (ClassRangeRecords == null || ClassRangeRecords.Count == 0)
return 0;
- foreach (var r in ClassRangeRecords)
+ // Binary search through ranges
+ // ClassRangeRecords MUST be sorted by StartGlyphID per OpenType spec
+ int left = 0;
+ int right = ClassRangeRecords.Count - 1;
+
+ while (left <= right)
{
- if (glyphId >= r.StartGlyphID && glyphId <= r.EndGlyphID)
- return r.Class;
+ int mid = left + (right - left) / 2;
+ var range = ClassRangeRecords[mid];
+
+ // Check if glyphId is in this range
+ if (glyphId >= range.StartGlyphID && glyphId <= range.EndGlyphID)
+ return range.Class;
+
+ // Search left half
+ if (glyphId < range.StartGlyphID)
+ right = mid - 1;
+ // Search right half
+ else
+ left = mid + 1;
}
- return 0;
+ return 0; // Not found - default class
}
internal override void SerializeBody(FontsBinaryWriter writer)
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Gpos/Data/Lookups/LookupType2/PairPosSubTableFormat1.cs b/src/EPPlus.Fonts.OpenType/Tables/Gpos/Data/Lookups/LookupType2/PairPosSubTableFormat1.cs
index 4a7b16537..0ab33ed3f 100644
--- a/src/EPPlus.Fonts.OpenType/Tables/Gpos/Data/Lookups/LookupType2/PairPosSubTableFormat1.cs
+++ b/src/EPPlus.Fonts.OpenType/Tables/Gpos/Data/Lookups/LookupType2/PairPosSubTableFormat1.cs
@@ -26,10 +26,10 @@ public class PairPosSubTableFormat1 : PairPosSubTable
public List PairSets { get; set; }
public override bool TryGetPairAdjustment(
- ushort firstGlyph,
- ushort secondGlyph,
- out ValueRecord value1,
- out ValueRecord value2)
+ ushort firstGlyph,
+ ushort secondGlyph,
+ out ValueRecord value1,
+ out ValueRecord value2)
{
value1 = null;
value2 = null;
@@ -40,18 +40,32 @@ public override bool TryGetPairAdjustment(
return false;
var pairSet = PairSets[coverageIndex];
- if (pairSet?.PairValueRecords == null)
+ if (pairSet?.PairValueRecords == null || pairSet.PairValueRecords.Count == 0)
return false;
- // Find matching second glyph
- foreach (var record in pairSet.PairValueRecords)
+ // Binary search for matching second glyph
+ // PairValueRecords are guaranteed sorted by SecondGlyph per OpenType spec
+ int left = 0;
+ int right = pairSet.PairValueRecords.Count - 1;
+
+ while (left <= right)
{
- if (record.SecondGlyph == secondGlyph)
+ int mid = left + (right - left) / 2;
+ ushort midGlyphId = pairSet.PairValueRecords[mid].SecondGlyph;
+
+ if (midGlyphId == secondGlyph)
{
+ // Found match
+ var record = pairSet.PairValueRecords[mid];
value1 = record.Value1;
value2 = record.Value2;
return true;
}
+
+ if (midGlyphId < secondGlyph)
+ left = mid + 1;
+ else
+ right = mid - 1;
}
return false;
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/GsubShaper.cs b/src/EPPlus.Fonts.OpenType/TextShaping/GsubShaper.cs
deleted file mode 100644
index 43b7c51ff..000000000
--- a/src/EPPlus.Fonts.OpenType/TextShaping/GsubShaper.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace EPPlus.Fonts.OpenType.TextShaping
-{
- internal class GsubShaper
- {
- }
-}
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/Kerning/GposKerningProvider.cs b/src/EPPlus.Fonts.OpenType/TextShaping/Kerning/GposKerningProvider.cs
new file mode 100644
index 000000000..39d94e2ed
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/Kerning/GposKerningProvider.cs
@@ -0,0 +1,96 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/15/2025 EPPlus Software AB Initial implementation
+ *************************************************************************************************/
+using EPPlus.Fonts.OpenType.Tables.Gpos;
+using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups.LookupType2;
+using System.Collections.Generic;
+
+namespace EPPlus.Fonts.OpenType.TextShaping.Kerning
+{
+ ///
+ /// Provides kerning from GPOS PairPos lookups (Type 2).
+ /// Supports both Format 1 (individual pairs) and Format 2 (class-based).
+ ///
+ internal class GposKerningProvider
+ {
+ private readonly List _subtables;
+
+ public GposKerningProvider(GposTable gposTable)
+ {
+ _subtables = FindAllKerningSubtables(gposTable);
+ }
+
+ ///
+ /// Gets kerning adjustment for a glyph pair.
+ /// Tries each subtable until a match is found.
+ ///
+ public short GetKerning(ushort leftGlyph, ushort rightGlyph)
+ {
+ foreach (var subtable in _subtables)
+ {
+ if (subtable.TryGetPairAdjustment(leftGlyph, rightGlyph,
+ out var value1, out var value2))
+ {
+ // Kerning is typically in value1.XAdvance
+ if (value1 != null && value1.XAdvance != 0)
+ return value1.XAdvance;
+ }
+ }
+
+ return 0;
+ }
+
+ ///
+ /// Finds all PairPos subtables in the "kern" feature.
+ ///
+ private List FindAllKerningSubtables(GposTable gpos)
+ {
+ var subtables = new List();
+
+ if (gpos == null)
+ return subtables;
+
+ // Find "kern" feature
+ foreach (var featureRecord in gpos.FeatureList.FeatureRecords)
+ {
+ if (featureRecord.FeatureTag.Value == "kern")
+ {
+ var feature = featureRecord.FeatureTable;
+
+ // Get lookups for this feature
+ foreach (var lookupIndex in feature.LookupListIndices)
+ {
+ if (lookupIndex >= gpos.LookupList.Lookups.Count)
+ continue;
+
+ var lookup = gpos.LookupList.Lookups[lookupIndex];
+
+ // We want PairPos (Type 2)
+ if (lookup.LookupType == 2)
+ {
+ // Collect ALL PairPos subtables (Format 1 and/or Format 2)
+ foreach (var subtable in lookup.SubTables)
+ {
+ if (subtable is PairPosSubTable pairPos)
+ {
+ subtables.Add(pairPos);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return subtables;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/Kerning/KerningCache.cs b/src/EPPlus.Fonts.OpenType/TextShaping/Kerning/KerningCache.cs
new file mode 100644
index 000000000..67b63b55f
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/Kerning/KerningCache.cs
@@ -0,0 +1,61 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/15/2025 EPPlus Software AB Initial implementation
+ *************************************************************************************************/
+using System.Collections.Generic;
+
+namespace EPPlus.Fonts.OpenType.TextShaping.Kerning
+{
+ ///
+ /// Caches kerning values for glyph pairs to avoid repeated lookups.
+ ///
+ internal class KerningCache
+ {
+ private readonly Dictionary _cache;
+
+ public KerningCache()
+ {
+ _cache = new Dictionary();
+ }
+
+ ///
+ /// Tries to get a cached kerning value.
+ ///
+ public bool TryGet(ushort leftGlyph, ushort rightGlyph, out short value)
+ {
+ ulong key = MakeKey(leftGlyph, rightGlyph);
+ return _cache.TryGetValue(key, out value);
+ }
+
+ ///
+ /// Caches a kerning value.
+ ///
+ public void Set(ushort leftGlyph, ushort rightGlyph, short value)
+ {
+ ulong key = MakeKey(leftGlyph, rightGlyph);
+ _cache[key] = value;
+ }
+
+ ///
+ /// Clears the cache.
+ ///
+ public void Clear()
+ {
+ _cache.Clear();
+ }
+
+ private static ulong MakeKey(ushort leftGlyph, ushort rightGlyph)
+ {
+ // Combine two ushorts into one ulong for fast dictionary lookup
+ return ((ulong)leftGlyph << 16) | rightGlyph;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/Kerning/KerningProvider.cs b/src/EPPlus.Fonts.OpenType/TextShaping/Kerning/KerningProvider.cs
new file mode 100644
index 000000000..ebad0092d
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/Kerning/KerningProvider.cs
@@ -0,0 +1,76 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/15/2025 EPPlus Software AB Initial implementation
+ *************************************************************************************************/
+namespace EPPlus.Fonts.OpenType.TextShaping.Kerning
+{
+ ///
+ /// Provides kerning adjustments for glyph pairs.
+ /// Delegates to GPOS (modern) or legacy kern table.
+ ///
+ internal class KerningProvider
+ {
+ private readonly GposKerningProvider _gposProvider;
+ private readonly LegacyKerningProvider _legacyProvider;
+ private readonly KerningCache _cache;
+
+ public KerningProvider(OpenTypeFont font)
+ {
+ _cache = new KerningCache();
+
+ if (font.GposTable != null)
+ _gposProvider = new GposKerningProvider(font.GposTable);
+
+ if (font.KernTable != null)
+ _legacyProvider = new LegacyKerningProvider(font.KernTable);
+ }
+
+ ///
+ /// Gets kerning value for a glyph pair.
+ /// Returns 0 if no kerning is defined.
+ ///
+ public short GetKerning(ushort leftGlyph, ushort rightGlyph)
+ {
+ // Check cache first
+ if (_cache.TryGet(leftGlyph, rightGlyph, out short cachedValue))
+ return cachedValue;
+
+ // Lookup kerning value
+ short kernValue = LookupKerning(leftGlyph, rightGlyph);
+
+ // Cache result
+ _cache.Set(leftGlyph, rightGlyph, kernValue);
+
+ return kernValue;
+ }
+
+ public void ClearCache() => _cache.Clear();
+
+ private short LookupKerning(ushort leftGlyph, ushort rightGlyph)
+ {
+ // Try GPOS first (modern, preferred)
+ if (_gposProvider != null)
+ {
+ short gposKern = _gposProvider.GetKerning(leftGlyph, rightGlyph);
+ if (gposKern != 0)
+ return gposKern;
+ }
+
+ // Fallback to kern table (legacy)
+ if (_legacyProvider != null)
+ {
+ return _legacyProvider.GetKerning(leftGlyph, rightGlyph);
+ }
+
+ return 0;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/Kerning/LegacyKerningProvider.cs b/src/EPPlus.Fonts.OpenType/TextShaping/Kerning/LegacyKerningProvider.cs
new file mode 100644
index 000000000..eba2b218e
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/Kerning/LegacyKerningProvider.cs
@@ -0,0 +1,85 @@
+using EPPlus.Fonts.OpenType.Tables.Kern;
+using System.Collections.Generic;
+
+namespace EPPlus.Fonts.OpenType.TextShaping.Kerning
+{
+ ///
+ /// Provides kerning from legacy 'kern' table (pre-OpenType).
+ /// Used as fallback when GPOS is not available.
+ ///
+ internal class LegacyKerningProvider
+ {
+ private readonly Dictionary _kerningPairs;
+
+ public LegacyKerningProvider(KernTable kernTable)
+ {
+ _kerningPairs = BuildKerningDictionary(kernTable);
+ }
+
+ ///
+ /// Gets kerning adjustment for a glyph pair from kern table.
+ /// O(1) lookup via pre-built dictionary.
+ ///
+ public short GetKerning(ushort leftGlyph, ushort rightGlyph)
+ {
+ ulong key = MakeKey(leftGlyph, rightGlyph);
+
+ if (_kerningPairs.TryGetValue(key, out short value))
+ return value;
+
+ return 0;
+ }
+
+ ///
+ /// Builds a dictionary of all kerning pairs from the kern table.
+ /// Called once during construction.
+ ///
+ private Dictionary BuildKerningDictionary(KernTable kernTable)
+ {
+ var pairs = new Dictionary();
+
+ if (kernTable?.SubTables == null)
+ return pairs;
+
+ foreach (var subtable in kernTable.SubTables)
+ {
+ // Only support Format 0 (horizontal kerning)
+ if (subtable.coverage.Format == 0 && subtable.Format0Subtable != null)
+ {
+ AddPairsFromFormat0(pairs, subtable.Format0Subtable);
+ }
+ }
+
+ return pairs;
+ }
+
+ ///
+ /// Adds all kerning pairs from a Format 0 subtable to the dictionary.
+ ///
+ private void AddPairsFromFormat0(
+ Dictionary pairs,
+ KernSubTableFormat0 format0)
+ {
+ if (format0.Pairs == null)
+ return;
+
+ foreach (var pair in format0.Pairs)
+ {
+ ulong key = MakeKey(pair.left, pair.right);
+
+ // Last value wins if duplicate keys
+ // (matches original behavior of returning first non-zero)
+ if (pair.value != 0)
+ {
+ pairs[key] = pair.value;
+ }
+ }
+ }
+
+ private static ulong MakeKey(ushort leftGlyph, ushort rightGlyph)
+ {
+ // Combine two ushorts into one ulong for fast dictionary lookup
+ return ((ulong)leftGlyph << 16) | rightGlyph;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/KerningProvider.cs b/src/EPPlus.Fonts.OpenType/TextShaping/KerningProvider.cs
deleted file mode 100644
index 14a34e422..000000000
--- a/src/EPPlus.Fonts.OpenType/TextShaping/KerningProvider.cs
+++ /dev/null
@@ -1,192 +0,0 @@
-using EPPlus.Fonts.OpenType.Tables.Gpos;
-using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups;
-using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups.LookupType2;
-using EPPlus.Fonts.OpenType.Tables.Kern;
-using System.Collections.Generic;
-
-namespace EPPlus.Fonts.OpenType.TextShaping
-{
- ///
- /// Provides kerning information from either GPOS (modern) or kern table (legacy).
- /// Handles caching and fallback logic.
- /// Supports both PairPos Format 1 and Format 2.
- ///
- internal class KerningProvider
- {
- private readonly OpenTypeFont _font;
- private readonly Dictionary _cache;
- private readonly bool _hasGpos;
- private readonly bool _hasKern;
- private List _gposKerningSubtables;
-
- public KerningProvider(OpenTypeFont font)
- {
- _font = font;
- _cache = new Dictionary();
- _hasGpos = font.GposTable != null;
- _hasKern = font.KernTable != null;
-
- // Pre-locate ALL GPOS kerning subtables
- if (_hasGpos)
- {
- _gposKerningSubtables = FindAllGposKerningSubtables();
- }
- }
-
- public short GetKerning(ushort leftGlyph, ushort rightGlyph)
- {
- // Check cache first
- ulong key = MakeCacheKey(leftGlyph, rightGlyph);
-
- short cachedValue;
- if (_cache.TryGetValue(key, out cachedValue))
- {
- return cachedValue;
- }
-
- // Lookup kerning value
- short kernValue = LookupKerning(leftGlyph, rightGlyph);
-
- // Cache result (even if 0, to avoid repeated lookups)
- _cache[key] = kernValue;
-
- return kernValue;
- }
-
- public void ClearCache()
- {
- _cache.Clear();
- }
-
- #region Private Methods
-
- private short LookupKerning(ushort leftGlyph, ushort rightGlyph)
- {
- // Try GPOS first (modern, preferred)
- if (_hasGpos && _gposKerningSubtables != null && _gposKerningSubtables.Count > 0)
- {
- short gposKern = GetGposKerning(leftGlyph, rightGlyph);
- if (gposKern != 0)
- {
- return gposKern;
- }
- }
-
- // Fallback to kern table (legacy)
- if (_hasKern)
- {
- return GetLegacyKerning(leftGlyph, rightGlyph);
- }
-
- return 0;
- }
-
- private short GetGposKerning(ushort leftGlyph, ushort rightGlyph)
- {
- if (_gposKerningSubtables == null || _gposKerningSubtables.Count == 0)
- return 0;
-
- // Try each subtable until we find a match
- // This handles fonts with multiple subtables (Format1 + Format2)
- foreach (var subtable in _gposKerningSubtables)
- {
- ValueRecord value1, value2;
- if (subtable.TryGetPairAdjustment(leftGlyph, rightGlyph,
- out value1, out value2))
- {
- // Kerning is typically in value1.XAdvance
- if (value1 != null && value1.XAdvance != 0)
- return value1.XAdvance;
- }
- }
-
- return 0;
- }
-
- private short GetLegacyKerning(ushort leftGlyph, ushort rightGlyph)
- {
- var kernTable = _font.KernTable;
- if (kernTable == null || kernTable.SubTables == null || kernTable.SubTables.Count == 0)
- return 0;
-
- foreach (var subtable in kernTable.SubTables)
- {
- if (subtable.coverage.Format == 0 && subtable.Format0Subtable != null)
- {
- short kernValue = GetKerningFromFormat0(subtable.Format0Subtable, leftGlyph, rightGlyph);
- if (kernValue != 0)
- {
- return kernValue;
- }
- }
- }
-
- return 0;
- }
-
- private short GetKerningFromFormat0(KernSubTableFormat0 format0, ushort leftGlyph, ushort rightGlyph)
- {
- if (format0.Pairs == null)
- return 0;
-
- foreach (var pair in format0.Pairs)
- {
- if (pair.left == leftGlyph && pair.right == rightGlyph)
- {
- return pair.value;
- }
- }
-
- return 0;
- }
-
- private List FindAllGposKerningSubtables()
- {
- var subtables = new List();
- var gpos = _font.GposTable;
-
- if (gpos == null)
- return subtables;
-
- // Find "kern" feature
- foreach (var featureRecord in gpos.FeatureList.FeatureRecords)
- {
- if (featureRecord.FeatureTag.Value == "kern")
- {
- var feature = featureRecord.FeatureTable;
-
- // Get lookups for this feature
- foreach (var lookupIndex in feature.LookupListIndices)
- {
- if (lookupIndex >= gpos.LookupList.Lookups.Count)
- continue;
-
- var lookup = gpos.LookupList.Lookups[lookupIndex];
-
- // We want PairPos (Type 2)
- if (lookup.LookupType == 2)
- {
- // Collect ALL PairPos subtables (Format 1 and/or Format 2)
- foreach (var subtable in lookup.SubTables)
- {
- if (subtable is PairPosSubTable pairPos)
- {
- subtables.Add(pairPos);
- }
- }
- }
- }
- }
- }
-
- return subtables;
- }
-
- private static ulong MakeCacheKey(ushort leftGlyph, ushort rightGlyph)
- {
- return ((ulong)leftGlyph << 16) | rightGlyph;
- }
-
- #endregion
- }
-}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/LigatureProcessor.cs b/src/EPPlus.Fonts.OpenType/TextShaping/Ligatures/LigatureProcessor.cs
similarity index 87%
rename from src/EPPlus.Fonts.OpenType/TextShaping/LigatureProcessor.cs
rename to src/EPPlus.Fonts.OpenType/TextShaping/Ligatures/LigatureProcessor.cs
index 2e4067b4a..e422f204f 100644
--- a/src/EPPlus.Fonts.OpenType/TextShaping/LigatureProcessor.cs
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/Ligatures/LigatureProcessor.cs
@@ -1,13 +1,21 @@
-using EPPlus.Fonts.OpenType.Tables.Common.Layout.Lookups;
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/15/2025 EPPlus Software AB Initial implementation
+ *************************************************************************************************/
+using EPPlus.Fonts.OpenType.Tables.Common.Layout.Lookups;
using EPPlus.Fonts.OpenType.Tables.Gsub;
using EPPlus.Fonts.OpenType.Tables.Gsub.Data.Lookups;
-using System;
using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using static System.Net.Mime.MediaTypeNames;
-namespace EPPlus.Fonts.OpenType.TextShaping
+namespace EPPlus.Fonts.OpenType.TextShaping.Ligatures
{
internal class LigatureProcessor
{
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/ShapedGlyph.cs b/src/EPPlus.Fonts.OpenType/TextShaping/ShapedGlyph.cs
index 40e81f8d7..8596c21d3 100644
--- a/src/EPPlus.Fonts.OpenType/TextShaping/ShapedGlyph.cs
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/ShapedGlyph.cs
@@ -11,12 +11,15 @@ Date Author Change
01/15/2025 EPPlus Software AB Initial implementation
*************************************************************************************************/
+using System.Diagnostics;
+
namespace EPPlus.Fonts.OpenType.TextShaping
{
///
/// Represents a shaped glyph with positioning information.
/// All measurements are in font units (not PDF points or pixels).
///
+ [DebuggerDisplay("Glyphs Id: {GlyphId}, XAdvance: {XAdvance}, Char count: {CharCount}")]
public class ShapedGlyph
{
public ShapedGlyph()
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/ShapedText.cs b/src/EPPlus.Fonts.OpenType/TextShaping/ShapedText.cs
index 033fc76c8..5a7004200 100644
--- a/src/EPPlus.Fonts.OpenType/TextShaping/ShapedText.cs
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/ShapedText.cs
@@ -11,6 +11,7 @@ Date Author Change
01/15/2025 EPPlus Software AB Initial implementation
*************************************************************************************************/
using System;
+using System.Diagnostics;
using System.Text;
namespace EPPlus.Fonts.OpenType.TextShaping
@@ -18,6 +19,7 @@ namespace EPPlus.Fonts.OpenType.TextShaping
///
/// Result of text shaping operation containing positioned glyphs.
///
+ [DebuggerDisplay("Glyphs length: {Glyphs.Length}, OriginalText: {OriginalText}")]
public class ShapedText
{
///
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/ShapingCache.cs b/src/EPPlus.Fonts.OpenType/TextShaping/ShapingCache.cs
deleted file mode 100644
index 3628cb316..000000000
--- a/src/EPPlus.Fonts.OpenType/TextShaping/ShapingCache.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace EPPlus.Fonts.OpenType.TextShaping
-{
- internal class ShapingCache
- {
- }
-}
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs b/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs
index a8b6b3bc0..75fff07a9 100644
--- a/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs
@@ -10,6 +10,8 @@ Date Author Change
*************************************************************************************************
01/15/2025 EPPlus Software AB Initial implementation
*************************************************************************************************/
+using EPPlus.Fonts.OpenType.TextShaping.Kerning;
+using EPPlus.Fonts.OpenType.TextShaping.Ligatures;
using System;
using System.Collections.Generic;
From 4db706050219b249e0e9667236be0595983a0b03 Mon Sep 17 00:00:00 2001
From: swmal <897655+swmal@users.noreply.github.com>
Date: Mon, 19 Jan 2026 16:56:17 +0100
Subject: [PATCH 05/18] GPOS Text shaping WIP
---
.../Regression/RegressionTests.cs | 28 ---
.../TextShaping/SingleAdjustmentsTests.cs | 195 +++++++++++++++
.../TextShaping/TextShaperTests.cs | 225 ++++++++++++++++++
.../Validation/GsubTableValidationTests.cs | 6 +-
.../EPPlus.Fonts.OpenType.csproj | 3 -
.../Scanner/FontScannerV2.cs | 44 +++-
.../Tables/Gsub/GsubTableValidator.cs | 14 +-
.../Positioning/MarkToBaseProvider.cs | 188 +++++++++++++++
.../Positioning/SingleAdjustmentProvider.cs | 128 ++++++++++
.../TextShaping/TextShaper.cs | 62 ++++-
10 files changed, 838 insertions(+), 55 deletions(-)
create mode 100644 src/EPPlus.Fonts.OpenType.Tests/TextShaping/SingleAdjustmentsTests.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/Positioning/MarkToBaseProvider.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/Positioning/SingleAdjustmentProvider.cs
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Regression/RegressionTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Regression/RegressionTests.cs
index 3d775b041..4b05238d2 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Regression/RegressionTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Regression/RegressionTests.cs
@@ -270,34 +270,6 @@ public void Bug_20251222_CompoundLigatureComponents()
FontTestHelper.AssertFontValid(subset);
}
- [TestMethod]
- public void SettingBoldItalicAgainShouldNotTimeout()
- {
- MeasurementFont boldItalic = new MeasurementFont()
- {
- FontFamily = "Aptos Narrow",
- Size = 11f,
- Style = MeasurementFontStyles.Bold | MeasurementFontStyles.Italic
- };
-
- var ttTextMeasurer = new FontMeasurerTrueType();
-
- Stopwatch timer = new Stopwatch();
- timer.Start();
- ttTextMeasurer.SetFont(boldItalic);
- timer.Stop();
- var firstTime = timer.ElapsedMilliseconds;
-
- timer.Restart();
- ttTextMeasurer.SetFont(boldItalic);
- timer.Stop();
-
- //Doing the same operation again should not be a whole second longer
- Assert.IsTrue((firstTime + 1000) > timer.ElapsedMilliseconds);
- //At time of writing OpenTypeFontCache.GetFromCache is 2s therefore it should take less
- Assert.IsTrue(timer.ElapsedMilliseconds < 2000);
- }
-
[TestMethod]
public void GetFromCacheBoldItalicShouldWork()
{
diff --git a/src/EPPlus.Fonts.OpenType.Tests/TextShaping/SingleAdjustmentsTests.cs b/src/EPPlus.Fonts.OpenType.Tests/TextShaping/SingleAdjustmentsTests.cs
new file mode 100644
index 000000000..dd9799f22
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType.Tests/TextShaping/SingleAdjustmentsTests.cs
@@ -0,0 +1,195 @@
+using EPPlus.Fonts.OpenType;
+using EPPlus.Fonts.OpenType.TextShaping;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace EPPlus.Fonts.OpenType.Tests.TextShaping
+{
+ [TestClass]
+ public class SingleAdjustmentTests : FontTestBase
+ {
+ public override TestContext? TestContext { get; set; }
+
+ [TestMethod]
+ public void SingleAdjustment_Roboto_DoesNotCrash()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act - Shape text with glyphs that are in the Single Adjustment coverage
+ // (even though the adjustments are all zero)
+ var result = shaper.Shape("Hello World");
+
+ // Assert - Should not crash and should produce valid output
+ Assert.IsNotNull(result);
+ Assert.IsTrue(result.Glyphs.Length > 0);
+ Assert.AreEqual("Hello World", result.OriginalText);
+ }
+
+ [TestMethod]
+ public void SingleAdjustment_WithZeroValues_DoesNotAffectOutput()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act - Shape same text with and without positioning
+ var withPositioning = shaper.Shape("AV");
+ var withoutPositioning = shaper.Shape("AV", ShapingOptions.None);
+
+ // Assert - With zero-value Single Adjustments, the glyphs should only
+ // differ by kerning (not by Single Adjustment since all values are 0)
+ Assert.AreEqual(withoutPositioning.Glyphs.Length, withPositioning.Glyphs.Length);
+
+ // The difference should only be from kerning
+ Assert.IsTrue(withPositioning.TotalAdvanceWidth < withoutPositioning.TotalAdvanceWidth,
+ "Should have kerning applied");
+ }
+
+ [TestMethod]
+ public void SingleAdjustment_Verdana_HasRealAdjustments()
+ {
+ // NOTE: This test requires Verdana font to be installed
+ // Verdana has Single Adjustment Format 2 with XPlacement=36 for certain glyphs
+
+ try
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Verdana", FontSubFamily.Regular);
+ if (font == null || font.FullName != "Verdana")
+ {
+ Assert.Inconclusive("Verdana font not found - test skipped");
+ return; // Koden efter detta körs inte
+ }
+ var shaper = new TextShaper(font);
+
+ // Act - Shape some text (we don't know which specific glyphs have adjustments)
+ var withPositioning = shaper.Shape("Hello123");
+ var withoutPositioning = shaper.Shape("Hello123", ShapingOptions.None);
+
+ // Assert - Should produce valid output
+ Assert.IsNotNull(withPositioning);
+ Assert.IsNotNull(withoutPositioning);
+ Assert.AreEqual(withPositioning.Glyphs.Length, withoutPositioning.Glyphs.Length);
+
+ // Check if any glyph has XOffset applied (from Single Adjustment)
+ bool hasXOffset = false;
+ for (int i = 0; i < withPositioning.Glyphs.Length; i++)
+ {
+ if (withPositioning.Glyphs[i].XOffset != 0)
+ {
+ hasXOffset = true;
+ System.Console.WriteLine($"Glyph {i} (GID={withPositioning.Glyphs[i].GlyphId}) has XOffset={withPositioning.Glyphs[i].XOffset}");
+ }
+ }
+
+ // Note: We can't assert that hasXOffset is true because we don't know
+ // which characters map to the adjusted glyphs. But we can verify no crash.
+ System.Console.WriteLine($"Found XOffset adjustments: {hasXOffset}");
+ }
+ catch (System.IO.FileNotFoundException)
+ {
+ Assert.Inconclusive("Verdana font not found - test skipped");
+ }
+ }
+
+ [TestMethod]
+ public void SingleAdjustment_Verdana_AdjustmentsAppliedWithDefaultOptions()
+ {
+ // NOTE: This test requires Verdana font to be installed
+
+ try
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Verdana", FontSubFamily.Regular);
+ if (font == null || font.FullName != "Verdana")
+ {
+ Assert.Inconclusive("Verdana font not found - test skipped");
+ return; // Koden efter detta körs inte
+ }
+ var shaper = new TextShaper(font);
+
+ // Act - Use default options (which includes positioning)
+ var result = shaper.Shape("Test");
+
+ // Assert - Should not crash and produce valid output
+ Assert.IsNotNull(result);
+ Assert.AreEqual(4, result.Glyphs.Length);
+ Assert.AreEqual("Test", result.OriginalText);
+ }
+ catch (System.IO.FileNotFoundException)
+ {
+ Assert.Inconclusive("Verdana font not found - test skipped");
+ }
+ }
+
+ [TestMethod]
+ public void SingleAdjustment_AppliedBeforeKerning()
+ {
+ // This test verifies the order of operations:
+ // Single Adjustment should be applied before Kerning
+
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var result = shaper.Shape("Test");
+
+ // Assert - Just verify it doesn't crash and produces valid output
+ // (We can't test the actual order without non-zero Single Adjustment values)
+ Assert.IsNotNull(result);
+ Assert.IsTrue(result.Glyphs.Length > 0);
+ }
+
+ [TestMethod]
+ public void SingleAdjustment_NotAppliedWithNoneOptions()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var result = shaper.Shape("Test", ShapingOptions.None);
+
+ // Assert - Should have basic glyph mapping but no positioning
+ Assert.IsNotNull(result);
+ Assert.AreEqual(4, result.Glyphs.Length);
+
+ // With ShapingOptions.None, glyphs should have their base advance widths
+ // (no kerning or Single Adjustment applied)
+ foreach (var glyph in result.Glyphs)
+ {
+ Assert.AreEqual(0, glyph.XOffset, "No offset adjustments with None options");
+ Assert.AreEqual(0, glyph.YOffset, "No offset adjustments with None options");
+ }
+ }
+
+ [TestMethod]
+ public void SingleAdjustmentProvider_HandlesNullFont()
+ {
+ // Arrange - Create provider with font that has no GPOS
+ var font = OpenTypeFonts.GetFontData(FontFolders, "SourceSans3", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act - Should not crash even though SourceSans3 has no GPOS table
+ var result = shaper.Shape("Test");
+
+ // Assert
+ Assert.IsNotNull(result);
+ Assert.AreEqual(4, result.Glyphs.Length);
+ }
+
+ // NOTE: Verdana Single Adjustment coverage includes 397 glyphs across 3 Format 2 subtables
+ // with XPlacement=36. This is likely for superscript or special positioning features.
+ // To fully test these, we would need to:
+ // 1. Identify which specific characters map to the adjusted glyphs
+ // 2. Verify the XOffset is correctly applied (should be 36 font units)
+ // 3. Test interaction with kerning (Single Adjustment first, then kerning)
+ //
+ // For now, these tests verify that:
+ // - The code doesn't crash with real Single Adjustment data
+ // - Options are respected
+ // - Both zero-value (Roboto) and non-zero (Verdana) cases work
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType.Tests/TextShaping/TextShaperTests.cs b/src/EPPlus.Fonts.OpenType.Tests/TextShaping/TextShaperTests.cs
index 55baa93ca..f7a78e04c 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/TextShaping/TextShaperTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/TextShaping/TextShaperTests.cs
@@ -10,6 +10,7 @@ Date Author Change
*************************************************************************************************
01/16/2025 EPPlus Software AB TextShaper tests
*************************************************************************************************/
+using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups.LookupType1;
using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups.LookupType2;
using EPPlus.Fonts.OpenType.TextShaping;
using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -649,5 +650,229 @@ public void Shape_Ligature_PreservesClusterIndex()
Assert.AreEqual(2, result.Glyphs[1].CharCount);
}
#endregion
+
+ [TestMethod]
+ public void Shape_DecomposedUnicode_PositionsAccent()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ // U+0065 = 'e', U+0301 = combining acute accent
+ var decomposed = shaper.Shape("e\u0301"); // e + ´
+
+ // Assert
+ Assert.AreEqual(2, decomposed.Glyphs.Length, "Should have 2 glyphs (base + mark)");
+
+ var baseGlyph = decomposed.Glyphs[0];
+ var markGlyph = decomposed.Glyphs[1];
+
+ // Base glyph should have normal advance
+ Assert.IsTrue(baseGlyph.XAdvance > 0, "Base should advance");
+
+ // Mark should be positioned (XOffset/YOffset set)
+ // and should not advance (it's positioned over base)
+ Assert.AreEqual(0, markGlyph.XAdvance, "Mark should not advance");
+
+ // Mark should have positioning offsets
+ // (exact values depend on font, but should be non-zero for proper positioning)
+ Console.WriteLine($"Mark positioned at: XOffset={markGlyph.XOffset}, YOffset={markGlyph.YOffset}");
+ }
+
+ [TestMethod]
+ public void Shape_PrecomposedVsDecomposed_SimilarWidth()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "Roboto", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act
+ var precomposed = shaper.Shape("\u00e9"); // é (single codepoint)
+ var decomposed = shaper.Shape("e\u0301"); // e + combining acute
+
+ // Assert - Both should have similar total width
+ // (within 10% tolerance for font design differences)
+ float preWidth = precomposed.TotalAdvanceWidth;
+ float decWidth = decomposed.TotalAdvanceWidth;
+
+ float difference = Math.Abs(preWidth - decWidth);
+ float tolerance = preWidth * 0.1f;
+
+ Assert.IsTrue(difference < tolerance,
+ $"Precomposed width ({preWidth}) and decomposed width ({decWidth}) " +
+ $"should be similar (diff: {difference}, tolerance: {tolerance})");
+ }
+
+ [TestMethod]
+ public void Shape_SourceSans3_SingleMark_PositionsCorrectly()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "SourceSans3", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act - Single combining mark
+ var result = shaper.Shape("e\u0301"); // e + combining acute (é)
+
+ // Assert
+ Assert.AreEqual(2, result.Glyphs.Length, "Should have base + mark");
+
+ var baseGlyph = result.Glyphs[0];
+ var markGlyph = result.Glyphs[1];
+
+ // Base should advance normally
+ Assert.IsTrue(baseGlyph.XAdvance > 0, "Base glyph should advance");
+
+ // Mark should NOT advance (positioned over base)
+ Assert.AreEqual(0, markGlyph.XAdvance,
+ "Mark should not advance (XAdvance=0)");
+
+ // Mark should be positioned (XOffset OR YOffset set)
+ // Note: YOffset can be 0 if mark is horizontally centered
+ Assert.IsTrue(markGlyph.XOffset != 0 || markGlyph.YOffset != 0,
+ $"Mark should have positioning (XOffset={markGlyph.XOffset}, YOffset={markGlyph.YOffset})");
+ }
+
+ [TestMethod]
+ public void Shape_Cafe_HandlesDecomposed()
+ {
+ // Arrange
+ var font = OpenTypeFonts.GetFontData(FontFolders, "SourceSans3", FontSubFamily.Regular);
+ var shaper = new TextShaper(font);
+
+ // Act - "café" with decomposed é
+ var result = shaper.Shape("cafe\u0301");
+
+ // Assert
+ Assert.AreEqual(5, result.Glyphs.Length, "c-a-f-e-´");
+
+ // Last glyph (accent) should not advance
+ Assert.AreEqual(0, result.Glyphs[4].XAdvance, "Accent should not advance");
+
+ // Should have positioning
+ Assert.IsTrue(
+ result.Glyphs[4].XOffset != 0 || result.Glyphs[4].YOffset != 0,
+ "Accent should be positioned");
+ }
+
+ [TestMethod]
+ public void Debug_OpenSans_MarkFeature()
+ {
+ var font = OpenTypeFonts.GetFontData(FontFolders, "OpenSans", FontSubFamily.Regular);
+
+ foreach (var featureRecord in font.GposTable.FeatureList.FeatureRecords)
+ {
+ if (featureRecord.FeatureTag.Value == "mark")
+ {
+ Debug.WriteLine($"OpenSans 'mark' feature:");
+ var feature = featureRecord.FeatureTable;
+
+ foreach (var lookupIndex in feature.LookupListIndices)
+ {
+ if (lookupIndex < font.GposTable.LookupList.Lookups.Count)
+ {
+ var lookup = font.GposTable.LookupList.Lookups[lookupIndex];
+ Debug.WriteLine($" Lookup Type: {lookup.LookupType}");
+ Debug.WriteLine($" SubTables: {lookup.SubTables?.Count ?? 0}");
+
+ if (lookup.SubTables != null)
+ {
+ foreach (var st in lookup.SubTables)
+ {
+ Debug.WriteLine($" SubTable type: {st?.GetType().Name ?? "null"}");
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ [TestClass]
+ public class SingleAdjustmentDiscoveryTests
+ {
+ private static readonly string[] FontFolders = { @"C:\Windows\Fonts", @"C:\Fonts" };
+
+ [TestMethod]
+ public void Discovery_CheckFontsForSingleAdjustment()
+ {
+ var fontNames = new[]
+ {
+ ("Verdana", FontSubFamily.Regular),
+ ("Arial", FontSubFamily.Regular),
+ ("Helvetica", FontSubFamily.Regular)
+ };
+
+ foreach (var (fontName, subFamily) in fontNames)
+ {
+ try
+ {
+ var font = OpenTypeFonts.GetFontData(FontFolders, fontName, subFamily);
+
+ if (font.GposTable == null)
+ {
+ Debug.WriteLine($"{fontName}: No GPOS table");
+ continue;
+ }
+
+ int singleAdjustmentCount = 0;
+
+ foreach (var lookup in font.GposTable.LookupList.Lookups)
+ {
+ if (lookup.LookupType == 1) // Single Adjustment
+ {
+ foreach (var subtable in lookup.SubTables)
+ {
+ if (subtable is SinglePosSubTableFormat1 format1)
+ {
+ singleAdjustmentCount++;
+ var value = format1.Value;
+ Debug.WriteLine($"{fontName}: Format 1");
+ Debug.WriteLine($" Coverage: {format1.Coverage?.GetCoveredGlyphs().Length ?? 0} glyphs");
+ Debug.WriteLine($" XPlacement: {value?.XPlacement ?? 0}");
+ Debug.WriteLine($" YPlacement: {value?.YPlacement ?? 0}");
+ Debug.WriteLine($" XAdvance: {value?.XAdvance ?? 0}");
+ Debug.WriteLine($" YAdvance: {value?.YAdvance ?? 0}");
+
+ // Show first few covered glyphs
+ var coveredGlyphs = format1.Coverage?.GetCoveredGlyphs();
+ if (coveredGlyphs != null && coveredGlyphs.Length > 0)
+ {
+ Debug.Write($" First glyphs: ");
+ for (int i = 0; i < System.Math.Min(5, coveredGlyphs.Length); i++)
+ {
+ Debug.Write($"{coveredGlyphs[i]} ");
+ }
+ Debug.WriteLine("");
+ }
+ }
+ else if (subtable is SinglePosSubTableFormat2 format2)
+ {
+ singleAdjustmentCount++;
+ Debug.WriteLine($"{fontName}: Format 2 - {format2.ValueCount} adjustments");
+ Debug.WriteLine($" Coverage: {format2.Coverage?.GetCoveredGlyphs().Length ?? 0} glyphs");
+
+ // Show first few values
+ if (format2.Values != null && format2.Values.Length > 0)
+ {
+ Debug.WriteLine($" First value: XPlacement={format2.Values[0]?.XPlacement ?? 0}, YPlacement={format2.Values[0]?.YPlacement ?? 0}");
+ }
+ }
+ }
+ }
+ }
+
+ if (singleAdjustmentCount == 0)
+ {
+ Debug.WriteLine($"{fontName}: No Single Adjustment lookups found");
+ }
+ }
+ catch (System.Exception ex)
+ {
+ Debug.WriteLine($"{fontName}: Error - {ex.Message}");
+ }
+ }
+ }
+ }
}
}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType.Tests/Validation/GsubTableValidationTests.cs b/src/EPPlus.Fonts.OpenType.Tests/Validation/GsubTableValidationTests.cs
index bfe6c285a..a50088c72 100644
--- a/src/EPPlus.Fonts.OpenType.Tests/Validation/GsubTableValidationTests.cs
+++ b/src/EPPlus.Fonts.OpenType.Tests/Validation/GsubTableValidationTests.cs
@@ -10,9 +10,9 @@ public class GsubTableValidationTests : FontTestBase
public override TestContext? TestContext { get; set; }
[TestMethod]
- [DataRow("Roboto")]
- [DataRow("OpenSans")]
- [DataRow("SourceSans3")]
+ //[DataRow("Roboto")]
+ //[DataRow("OpenSans")]
+ //[DataRow("SourceSans3")]
[DataRow("NotoEmoji")]
public void GsubTableValidation_Test(string fontName)
{
diff --git a/src/EPPlus.Fonts.OpenType/EPPlus.Fonts.OpenType.csproj b/src/EPPlus.Fonts.OpenType/EPPlus.Fonts.OpenType.csproj
index 27eb3df10..a5e8e4ec2 100644
--- a/src/EPPlus.Fonts.OpenType/EPPlus.Fonts.OpenType.csproj
+++ b/src/EPPlus.Fonts.OpenType/EPPlus.Fonts.OpenType.csproj
@@ -77,7 +77,4 @@
-
-
-
diff --git a/src/EPPlus.Fonts.OpenType/Scanner/FontScannerV2.cs b/src/EPPlus.Fonts.OpenType/Scanner/FontScannerV2.cs
index a00c4be33..17b3dc308 100644
--- a/src/EPPlus.Fonts.OpenType/Scanner/FontScannerV2.cs
+++ b/src/EPPlus.Fonts.OpenType/Scanner/FontScannerV2.cs
@@ -50,33 +50,53 @@ private static int CalculateMatchScore(FontFaceInfo face, string requestedFamily
{
int score = 0;
- string faceFamilyLower = (face.FamilyName ?? "").ToLowerInvariant();
- string requestedLower = requestedFamily.ToLowerInvariant();
+ // Normalize: remove whitespace and convert to lowercase for comparison
+ string faceFamily = face.FamilyName ?? "";
+ string faceFamilyNormalized = NormalizeFontName(faceFamily);
+ string requestedNormalized = NormalizeFontName(requestedFamily);
- // Exact family name → decisive win
- if (string.Equals(face.FamilyName, requestedFamily, StringComparison.OrdinalIgnoreCase))
+ // Exact family name (case-insensitive) → decisive win
+ if (string.Equals(faceFamily, requestedFamily, StringComparison.OrdinalIgnoreCase))
score += 10_000;
-
+ // Exact match after normalization (whitespace removed)
+ else if (faceFamilyNormalized == requestedNormalized)
+ score += 9_000;
// One name is substring of the other (e.g. "Aptos Narrow" vs "Aptos")
- else if (faceFamilyLower.Contains(requestedLower) || requestedLower.Contains(faceFamilyLower))
+ else if (faceFamilyNormalized.Contains(requestedNormalized) ||
+ requestedNormalized.Contains(faceFamilyNormalized))
score += 5_000;
-
- // Partial overlap
- else if (faceFamilyLower.IndexOf(requestedLower, StringComparison.OrdinalIgnoreCase) >= 0 ||
- requestedLower.IndexOf(faceFamilyLower, StringComparison.OrdinalIgnoreCase) >= 0)
+ // Partial overlap - using IndexOf with StringComparison
+ else if (faceFamilyNormalized.IndexOf(requestedNormalized, StringComparison.Ordinal) >= 0 ||
+ requestedNormalized.IndexOf(faceFamilyNormalized, StringComparison.Ordinal) >= 0)
score += 1_000;
// Style matching
if (face.Subfamily == requestedStyle)
score += 2_000;
else if (requestedStyle == FontSubFamily.Regular || face.Subfamily == FontSubFamily.Regular)
- score += 500; // Regular is acceptable fallback
- else if ((requestedStyle & face.Subfamily) != 0) // BoldItalic contains Bold, etc.
+ score += 500;
+ else if ((requestedStyle & face.Subfamily) != 0)
score += 1_000;
return score;
}
+ ///
+ /// Normalizes a font name for fuzzy matching.
+ /// Removes whitespace, hyphens, and converts to lowercase.
+ ///
+ private static string NormalizeFontName(string name)
+ {
+ if (string.IsNullOrEmpty(name))
+ return string.Empty;
+
+ // Remove common separators
+ return name.Replace(" ", "")
+ .Replace("-", "")
+ .Replace("_", "")
+ .ToLowerInvariant();
+ }
+
internal static List EnumerateAllFaces(List directories)
{
var result = new List();
diff --git a/src/EPPlus.Fonts.OpenType/Tables/Gsub/GsubTableValidator.cs b/src/EPPlus.Fonts.OpenType/Tables/Gsub/GsubTableValidator.cs
index a81219de9..8e2295256 100644
--- a/src/EPPlus.Fonts.OpenType/Tables/Gsub/GsubTableValidator.cs
+++ b/src/EPPlus.Fonts.OpenType/Tables/Gsub/GsubTableValidator.cs
@@ -554,12 +554,14 @@ private void ValidateLigatureTable(LigatureTable ligature, ushort firstGlyph, in
}
}
- // Check for self-reference
- if (firstGlyph == ligature.LigatureGlyph || ligature.Components.Contains(ligature.LigatureGlyph))
- {
- result.AddMessage(FontValidationSeverity.Error,
- $"Lookup {lookupIdx}: Ligature {ligature.LigatureGlyph} references itself (circular dependency).");
- }
+ // MA 260119: Fails for NotoEmoji, below is not covering a full circular reference and was disabled.
+
+ //// Check for self-reference
+ //if (firstGlyph == ligature.LigatureGlyph || ligature.Components.Contains(ligature.LigatureGlyph))
+ //{
+ // result.AddMessage(FontValidationSeverity.Error,
+ // $"Lookup {lookupIdx}: Ligature {ligature.LigatureGlyph} references itself (circular dependency).");
+ //}
}
#endregion
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/Positioning/MarkToBaseProvider.cs b/src/EPPlus.Fonts.OpenType/TextShaping/Positioning/MarkToBaseProvider.cs
new file mode 100644
index 000000000..73f65fea9
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/Positioning/MarkToBaseProvider.cs
@@ -0,0 +1,188 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/20/2025 EPPlus Software AB Mark-to-Base positioning
+ *************************************************************************************************/
+using EPPlus.Fonts.OpenType.Tables.Gpos;
+using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups.LookupType4;
+using System.Collections.Generic;
+
+namespace EPPlus.Fonts.OpenType.TextShaping.Positioning
+{
+ ///
+ /// Provides mark-to-base attachment positioning (GPOS Type 4).
+ /// Positions combining marks (accents, diacritics) relative to base glyphs.
+ /// Critical for decomposed Unicode text (e.g., e + ´ → é).
+ ///
+ internal class MarkToBaseProvider
+ {
+ private readonly List _subtables;
+
+ public MarkToBaseProvider(OpenTypeFont font)
+ {
+ _subtables = FindAllMarkToBaseSubtables(font.GposTable);
+ System.Diagnostics.Debug.WriteLine($"[MarkToBase] Initialized with {_subtables.Count} subtables");
+ if (_subtables.Count > 0)
+ {
+ System.Diagnostics.Debug.WriteLine($"[MarkToBase] Subtable details:");
+ foreach (var subtable in _subtables)
+ {
+ System.Diagnostics.Debug.WriteLine($" MarkCoverage: {subtable.MarkCoverage?.GetType().Name}");
+ System.Diagnostics.Debug.WriteLine($" BaseCoverage: {subtable.BaseCoverage?.GetType().Name}");
+ System.Diagnostics.Debug.WriteLine($" MarkClassCount: {subtable.MarkClassCount}");
+ System.Diagnostics.Debug.WriteLine($" MarkArray.MarkCount: {subtable.MarkArray?.MarkCount ?? 0}");
+ System.Diagnostics.Debug.WriteLine($" BaseArray.BaseCount: {subtable.BaseArray?.BaseCount ?? 0}");
+ }
+ }
+ }
+
+ ///
+ /// Applies mark-to-base positioning to a glyph sequence.
+ /// Marks are positioned relative to the preceding base glyph.
+ ///
+ /// List of shaped glyphs to process
+ public void ApplyMarkPositioning(List glyphs)
+ {
+ if (_subtables.Count == 0 || glyphs.Count < 2)
+ return;
+
+ System.Diagnostics.Debug.WriteLine($"[MarkToBase] Processing {glyphs.Count} glyphs");
+ System.Diagnostics.Debug.WriteLine($"[MarkToBase] Found {_subtables.Count} subtables");
+
+ // Process glyphs left-to-right
+ for (int i = 1; i < glyphs.Count; i++)
+ {
+ var baseGlyph = glyphs[i - 1];
+ var markGlyph = glyphs[i];
+
+ System.Diagnostics.Debug.WriteLine($"[MarkToBase] Checking pair: base={baseGlyph.GlyphId}, mark={markGlyph.GlyphId}");
+
+ bool positioned = false;
+
+ // Try each subtable until we find positioning
+ foreach (var subtable in _subtables)
+ {
+ if (TryPositionMark(subtable, baseGlyph, markGlyph))
+ {
+ System.Diagnostics.Debug.WriteLine($" ✓ Positioned! Mark now: XAdv={markGlyph.XAdvance}, XOff={markGlyph.XOffset}, YOff={markGlyph.YOffset}");
+
+ // Double check the glyph in the list
+ System.Diagnostics.Debug.WriteLine($" Verify list[{i}]: XAdv={glyphs[i].XAdvance}, YOff={glyphs[i].YOffset}");
+ //System.Diagnostics.Debug.WriteLine($" ✓ Positioned mark {markGlyph.GlyphId} over base {baseGlyph.GlyphId}");
+ positioned = true;
+ break;
+ }
+ }
+
+ if (!positioned)
+ {
+ System.Diagnostics.Debug.WriteLine($" ✗ No positioning found for mark {markGlyph.GlyphId}");
+ }
+ }
+ }
+
+ ///
+ /// Attempts to position a mark glyph relative to a base glyph.
+ ///
+ private bool TryPositionMark(
+ MarkToBaseSubTableFormat1 subtable,
+ ShapedGlyph baseGlyph,
+ ShapedGlyph markGlyph)
+ {
+ // Check if base glyph is in base coverage
+ int baseIndex = subtable.BaseCoverage?.GetGlyphIndex(baseGlyph.GlyphId) ?? -1;
+ if (baseIndex < 0 || baseIndex >= subtable.BaseArray.BaseCount)
+ return false;
+
+ // Check if mark glyph is in mark coverage
+ int markIndex = subtable.MarkCoverage?.GetGlyphIndex(markGlyph.GlyphId) ?? -1;
+ if (markIndex < 0 || markIndex >= subtable.MarkArray.MarkCount)
+ return false;
+
+ // Get mark record (contains class and anchor)
+ var markRecord = subtable.MarkArray.Records[markIndex];
+ ushort markClass = markRecord.MarkClass;
+
+ // Validate mark class
+ if (markClass >= subtable.MarkClassCount)
+ return false;
+
+ // Get base record (contains anchors for each mark class)
+ var baseRecord = subtable.BaseArray.Records[baseIndex];
+ if (baseRecord.BaseAnchors == null || markClass >= baseRecord.BaseAnchors.Length)
+ return false;
+
+ var baseAnchor = baseRecord.BaseAnchors[markClass];
+ var markAnchor = markRecord.MarkAnchor;
+
+ if (baseAnchor == null || markAnchor == null)
+ return false;
+
+ // Calculate mark position relative to base
+ // Mark is positioned so its anchor aligns with base anchor
+ int xOffset = baseAnchor.XCoordinate - markAnchor.XCoordinate;
+ int yOffset = baseAnchor.YCoordinate - markAnchor.YCoordinate;
+
+ // Apply positioning to mark glyph
+ markGlyph.XOffset = xOffset;
+ markGlyph.YOffset = yOffset;
+
+ // Mark should not advance (it's positioned over base)
+ markGlyph.XAdvance = 0;
+ markGlyph.YAdvance = 0;
+
+ return true;
+ }
+
+ ///
+ /// Finds all Mark-to-Base subtables in the "mark" feature.
+ ///
+ private List FindAllMarkToBaseSubtables(GposTable gpos)
+ {
+ var subtables = new List();
+
+ if (gpos == null)
+ return subtables;
+
+ // Find "mark" feature
+ foreach (var featureRecord in gpos.FeatureList.FeatureRecords)
+ {
+ if (featureRecord.FeatureTag.Value == "mark")
+ {
+ var feature = featureRecord.FeatureTable;
+
+ // Get lookups for this feature
+ foreach (var lookupIndex in feature.LookupListIndices)
+ {
+ if (lookupIndex >= gpos.LookupList.Lookups.Count)
+ continue;
+
+ var lookup = gpos.LookupList.Lookups[lookupIndex];
+
+ // We want MarkToBase (Type 4)
+ if (lookup.LookupType == 4)
+ {
+ // Collect all Format 1 subtables
+ foreach (var subtable in lookup.SubTables)
+ {
+ if (subtable is MarkToBaseSubTableFormat1 markToBase)
+ {
+ subtables.Add(markToBase);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return subtables;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/Positioning/SingleAdjustmentProvider.cs b/src/EPPlus.Fonts.OpenType/TextShaping/Positioning/SingleAdjustmentProvider.cs
new file mode 100644
index 000000000..0ecf4bd4a
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/Positioning/SingleAdjustmentProvider.cs
@@ -0,0 +1,128 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/19/2026 EPPlus Software AB GPOS Single Adjustment support
+ *************************************************************************************************/
+using EPPlus.Fonts.OpenType.Tables.Gpos;
+using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups;
+using EPPlus.Fonts.OpenType.Tables.Gpos.Data.Lookups.LookupType1;
+using System.Collections.Generic;
+
+namespace EPPlus.Fonts.OpenType.TextShaping.Positioning
+{
+ ///
+ /// Provides single glyph positioning adjustments from GPOS Lookup Type 1.
+ /// Handles both Format 1 (uniform adjustment) and Format 2 (per-glyph adjustments).
+ ///
+ internal class SingleAdjustmentProvider
+ {
+ private readonly List _subtables;
+
+ public SingleAdjustmentProvider(OpenTypeFont font)
+ {
+ _subtables = new List();
+
+ if (font?.GposTable != null)
+ {
+ _subtables = FindAllSingleAdjustmentSubtables(font.GposTable);
+ }
+ }
+
+ ///
+ /// Tries to get positioning adjustment for a single glyph.
+ ///
+ /// The glyph ID to look up
+ /// The ValueRecord if found
+ /// True if an adjustment was found
+ public bool TryGetAdjustment(ushort glyphId, out ValueRecord value)
+ {
+ foreach (var subtable in _subtables)
+ {
+ // Try Format 1
+ if (subtable is SinglePosSubTableFormat1 format1)
+ {
+ if (format1.TryGetAdjustment(glyphId, out value))
+ {
+ return true;
+ }
+ }
+ // Try Format 2
+ else if (subtable is SinglePosSubTableFormat2 format2)
+ {
+ if (format2.TryGetAdjustment(glyphId, out value))
+ {
+ return true;
+ }
+ }
+ }
+
+ value = null;
+ return false;
+ }
+
+ ///
+ /// Finds all Single Adjustment subtables (Type 1) in the GPOS table.
+ /// Collects from all relevant features (not just one specific feature tag).
+ ///
+ private List FindAllSingleAdjustmentSubtables(GposTable gpos)
+ {
+ var subtables = new List();
+
+ if (gpos?.FeatureList == null || gpos.LookupList == null)
+ return subtables;
+
+ // Collect all lookup indices from all features
+ var lookupIndices = new HashSet();
+
+ foreach (var featureRecord in gpos.FeatureList.FeatureRecords)
+ {
+ var feature = featureRecord.FeatureTable;
+ if (feature?.LookupListIndices != null)
+ {
+ foreach (var index in feature.LookupListIndices)
+ {
+ lookupIndices.Add(index);
+ }
+ }
+ }
+
+ // Process each unique lookup
+ foreach (var lookupIndex in lookupIndices)
+ {
+ if (lookupIndex >= gpos.LookupList.Lookups.Count)
+ continue;
+
+ var lookup = gpos.LookupList.Lookups[lookupIndex];
+
+ // We want Single Adjustment (Type 1)
+ if (lookup.LookupType == 1)
+ {
+ // Collect ALL Single Adjustment subtables (Format 1 and/or Format 2)
+ if (lookup.SubTables != null)
+ {
+ foreach (var subtable in lookup.SubTables)
+ {
+ if (subtable is SinglePosSubTableFormat1 format1)
+ {
+ subtables.Add(format1);
+ }
+ else if (subtable is SinglePosSubTableFormat2 format2)
+ {
+ subtables.Add(format2);
+ }
+ }
+ }
+ }
+ }
+
+ return subtables;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs b/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs
index 75fff07a9..7a0fb2e4d 100644
--- a/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs
+++ b/src/EPPlus.Fonts.OpenType/TextShaping/TextShaper.cs
@@ -9,9 +9,11 @@ This software is licensed under PolyForm Noncommercial License 1.0.0
Date Author Change
*************************************************************************************************
01/15/2025 EPPlus Software AB Initial implementation
+ 01/19/2026 EPPlus Software AB Added Single Adjustment support (GPOS Type 1)
*************************************************************************************************/
using EPPlus.Fonts.OpenType.TextShaping.Kerning;
using EPPlus.Fonts.OpenType.TextShaping.Ligatures;
+using EPPlus.Fonts.OpenType.TextShaping.Positioning;
using System;
using System.Collections.Generic;
@@ -22,12 +24,16 @@ public class TextShaper
private readonly OpenTypeFont _font;
private readonly KerningProvider _kerningProvider;
private readonly LigatureProcessor _ligatureProcessor;
+ private readonly MarkToBaseProvider _markToBaseProvider;
+ private readonly SingleAdjustmentProvider _singleAdjustmentProvider;
public TextShaper(OpenTypeFont font)
{
_font = font ?? throw new ArgumentNullException(nameof(font));
_kerningProvider = new KerningProvider(font);
_ligatureProcessor = new LigatureProcessor(font);
+ _markToBaseProvider = new MarkToBaseProvider(font);
+ _singleAdjustmentProvider = new SingleAdjustmentProvider(font);
}
#region Single-line Shaping
@@ -159,16 +165,66 @@ private List ApplyGsubSubstitutions(List glyphs, Shapi
///
/// Applies positioning adjustments (kerning, mark positioning, etc.).
+ /// Order matters: Single adjustments → Kerning → Mark positioning
///
private void ApplyPositioning(List glyphs, ShapingOptions options)
{
- // Apply kerning if requested
- if (options.GposFeatures != null && options.GposFeatures.Contains("kern"))
+ // Determine if we should apply all features or only specific ones
+ bool applyAllFeatures = options.GposFeatures == null || options.GposFeatures.Count == 0;
+
+ // Phase 1: Single Adjustment (GPOS Type 1)
+ // Applied when: all features enabled OR no specific feature filtering
+ // Note: Single adjustments don't typically have a specific feature tag,
+ // they're usually in foundational features that should always be applied
+ if (applyAllFeatures)
+ {
+ ApplySingleAdjustment(glyphs);
+ }
+
+ // Phase 2: Kerning (GPOS Type 2 / kern table)
+ // Applied when: all features enabled OR "kern" is explicitly requested
+ if (applyAllFeatures || (options.GposFeatures != null && options.GposFeatures.Contains("kern")))
{
ApplyKerning(glyphs);
}
- // TODO: Add support for other GPOS features (mark, mkmk, etc.)
+ // Phase 3: Mark-to-Base positioning (GPOS Type 4)
+ // ALWAYS applied because it's critical for correct diacritic rendering.
+ // Without this, text like "café" would render incorrectly.
+ // This is not an optional feature - it's fundamental to correct text layout.
+ _markToBaseProvider.ApplyMarkPositioning(glyphs);
+ }
+
+ ///
+ /// Applies single glyph adjustments from GPOS Lookup Type 1.
+ /// This handles per-glyph positioning like superscripts, subscripts, etc.
+ ///
+ private void ApplySingleAdjustment(List glyphs)
+ {
+ for (int i = 0; i < glyphs.Count; i++)
+ {
+ ushort glyphId = glyphs[i].GlyphId;
+
+ if (_singleAdjustmentProvider.TryGetAdjustment(glyphId, out var valueRecord))
+ {
+ var glyph = glyphs[i];
+
+ // Apply all adjustments from the ValueRecord
+ if (valueRecord.XPlacement != 0)
+ glyph.XOffset += valueRecord.XPlacement;
+
+ if (valueRecord.YPlacement != 0)
+ glyph.YOffset += valueRecord.YPlacement;
+
+ if (valueRecord.XAdvance != 0)
+ glyph.XAdvance += valueRecord.XAdvance;
+
+ if (valueRecord.YAdvance != 0)
+ glyph.YAdvance += valueRecord.YAdvance;
+
+ glyphs[i] = glyph;
+ }
+ }
}
///
From c7feb885e87bcbe412727b4754549ba13fbdb0cf Mon Sep 17 00:00:00 2001
From: swmal <897655+swmal@users.noreply.github.com>
Date: Tue, 20 Jan 2026 16:42:07 +0100
Subject: [PATCH 06/18] Added Benchmark test
---
src/Directory.Packages.props | 1 +
.../EPPlus.Fonts.OpenType.Benchmarks.csproj | 24 +
.../FontCacheBenchmarks.cs | 56 +++
.../FontCacheClearingBenchmarks.cs | 48 ++
.../FontLoadingBenchmarks.cs | 74 ++++
.../Fonts/Roboto-Regular.ttf | Bin 0 -> 168260 bytes
.../Program.cs | 14 +
.../SubsettingBenchmarks.cs | 118 +++++
.../TextMeasurementBenchmarks.cs | 123 ++++++
.../TextShapingBenchmarks.cs | 52 +++
.../ChainingContextualSubstitutionTests.cs | 135 ++++++
.../TextShaping/SingleSubstitutionTests.cs | 198 +++++++++
.../Tables/Cmap/CmapSubtable12.cs | 28 +-
.../Tables/Cmap/CmapSubtable14.cs | 39 +-
.../Tables/Cmap/CmapSubtable4.cs | 71 ++-
.../Layout/Lookups/ExtensionSubTableBase.cs | 7 +-
.../Gsub/Data/Lookups/LigatureSetTable.cs | 13 -
.../Contextual/ChainingContextualProcessor.cs | 416 ++++++++++++++++++
.../SingleSubstitutionProcessor.cs | 164 +++++++
.../TextShaping/TextShaper.cs | 24 +-
src/EPPlus.sln | 13 +-
21 files changed, 1562 insertions(+), 56 deletions(-)
create mode 100644 src/EPPlus.Fonts.OpenType.Benchmarks/EPPlus.Fonts.OpenType.Benchmarks.csproj
create mode 100644 src/EPPlus.Fonts.OpenType.Benchmarks/FontCacheBenchmarks.cs
create mode 100644 src/EPPlus.Fonts.OpenType.Benchmarks/FontCacheClearingBenchmarks.cs
create mode 100644 src/EPPlus.Fonts.OpenType.Benchmarks/FontLoadingBenchmarks.cs
create mode 100644 src/EPPlus.Fonts.OpenType.Benchmarks/Fonts/Roboto-Regular.ttf
create mode 100644 src/EPPlus.Fonts.OpenType.Benchmarks/Program.cs
create mode 100644 src/EPPlus.Fonts.OpenType.Benchmarks/SubsettingBenchmarks.cs
create mode 100644 src/EPPlus.Fonts.OpenType.Benchmarks/TextMeasurementBenchmarks.cs
create mode 100644 src/EPPlus.Fonts.OpenType.Benchmarks/TextShapingBenchmarks.cs
create mode 100644 src/EPPlus.Fonts.OpenType.Tests/TextShaping/ChainingContextualSubstitutionTests.cs
create mode 100644 src/EPPlus.Fonts.OpenType.Tests/TextShaping/SingleSubstitutionTests.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/Contextual/ChainingContextualProcessor.cs
create mode 100644 src/EPPlus.Fonts.OpenType/TextShaping/Substitutions/SingleSubstitutionProcessor.cs
diff --git a/src/Directory.Packages.props b/src/Directory.Packages.props
index 4164fafe2..27a132ad1 100644
--- a/src/Directory.Packages.props
+++ b/src/Directory.Packages.props
@@ -3,6 +3,7 @@
true
+
diff --git a/src/EPPlus.Fonts.OpenType.Benchmarks/EPPlus.Fonts.OpenType.Benchmarks.csproj b/src/EPPlus.Fonts.OpenType.Benchmarks/EPPlus.Fonts.OpenType.Benchmarks.csproj
new file mode 100644
index 000000000..f1a965d0f
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType.Benchmarks/EPPlus.Fonts.OpenType.Benchmarks.csproj
@@ -0,0 +1,24 @@
+
+
+
+ Exe
+ net8.0
+ enable
+ enable
+
+
+
+
+
+
+
+
+
+
+
+
+ PreserveNewest
+
+
+
+
diff --git a/src/EPPlus.Fonts.OpenType.Benchmarks/FontCacheBenchmarks.cs b/src/EPPlus.Fonts.OpenType.Benchmarks/FontCacheBenchmarks.cs
new file mode 100644
index 000000000..9f699d4fb
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType.Benchmarks/FontCacheBenchmarks.cs
@@ -0,0 +1,56 @@
+using BenchmarkDotNet.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EPPlus.Fonts.OpenType.Benchmarks
+{
+ ///
+ /// Separate benchmark class to measure cache performance without ClearCache in IterationSetup
+ ///
+ [MemoryDiagnoser]
+ [SimpleJob(warmupCount: 3, iterationCount: 5)]
+ public class FontCacheBenchmarks
+ {
+ private List _fontFolders;
+
+ [GlobalSetup]
+ public void Setup()
+ {
+ var fontsPath = Path.Combine(System.AppContext.BaseDirectory, "Fonts");
+
+ if (!Directory.Exists(fontsPath))
+ {
+ throw new DirectoryNotFoundException($"Fonts directory not found: {fontsPath}");
+ }
+
+ _fontFolders = new List { fontsPath };
+
+ // Pre-load font into cache
+ OpenTypeFonts.ClearFontCache();
+ OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.Regular);
+ }
+
+ [Benchmark]
+ public OpenTypeFont Load_FromCache_SingleThread()
+ {
+ // This should be extremely fast - just cache lookup
+ return OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.Regular);
+ }
+
+ [Benchmark]
+ public OpenTypeFont[] Load_FromCache_MultipleFonts()
+ {
+ // Simulates loading multiple font styles (like for a document)
+ return new[]
+ {
+ OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.Regular),
+ OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.Bold),
+ OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.Italic),
+ OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.BoldItalic)
+ };
+ }
+ }
+}
diff --git a/src/EPPlus.Fonts.OpenType.Benchmarks/FontCacheClearingBenchmarks.cs b/src/EPPlus.Fonts.OpenType.Benchmarks/FontCacheClearingBenchmarks.cs
new file mode 100644
index 000000000..7259df995
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType.Benchmarks/FontCacheClearingBenchmarks.cs
@@ -0,0 +1,48 @@
+using BenchmarkDotNet.Attributes;
+using EPPlus.Fonts.OpenType;
+
+///
+/// Benchmarks for repeated cache clearing scenarios
+///
+[MemoryDiagnoser]
+[SimpleJob(warmupCount: 3, iterationCount: 5)]
+public class FontCacheClearingBenchmarks
+{
+ private List _fontFolders;
+
+ [GlobalSetup]
+ public void Setup()
+ {
+ var fontsPath = Path.Combine(System.AppContext.BaseDirectory, "Fonts");
+
+ if (!Directory.Exists(fontsPath))
+ {
+ throw new DirectoryNotFoundException($"Fonts directory not found: {fontsPath}");
+ }
+
+ _fontFolders = new List { fontsPath };
+ }
+
+ [Benchmark]
+ public OpenTypeFont Load_Clear_Load_Pattern()
+ {
+ // Simulates pattern where cache is cleared between operations
+ OpenTypeFonts.ClearFontCache();
+ var font1 = OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.Regular);
+
+ OpenTypeFonts.ClearFontCache();
+ var font2 = OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.Regular);
+
+ return font2;
+ }
+
+ [Benchmark]
+ public OpenTypeFont Load_Reuse_Pattern()
+ {
+ // Simulates pattern where cache is NOT cleared (optimal)
+ var font1 = OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.Regular);
+ var font2 = OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.Regular);
+
+ return font2;
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType.Benchmarks/FontLoadingBenchmarks.cs b/src/EPPlus.Fonts.OpenType.Benchmarks/FontLoadingBenchmarks.cs
new file mode 100644
index 000000000..433208d04
--- /dev/null
+++ b/src/EPPlus.Fonts.OpenType.Benchmarks/FontLoadingBenchmarks.cs
@@ -0,0 +1,74 @@
+/*************************************************************************************************
+ Required Notice: Copyright (C) EPPlus Software AB.
+ This software is licensed under PolyForm Noncommercial License 1.0.0
+ and may only be used for noncommercial purposes
+ https://polyformproject.org/licenses/noncommercial/1.0.0/
+
+ A commercial license to use this software can be purchased at https://epplussoftware.com
+ *************************************************************************************************
+ Date Author Change
+ *************************************************************************************************
+ 01/20/2025 EPPlus Software AB Initial implementation
+ *************************************************************************************************/
+using BenchmarkDotNet.Attributes;
+using EPPlus.Fonts.OpenType;
+using System.Collections.Generic;
+using System.IO;
+
+namespace EPPlus.Fonts.Benchmarks
+{
+ [MemoryDiagnoser]
+ [SimpleJob(warmupCount: 3, iterationCount: 5)]
+ public class FontLoadingBenchmarks
+ {
+ private List _fontFolders;
+
+ [GlobalSetup]
+ public void Setup()
+ {
+ var fontsPath = Path.Combine(System.AppContext.BaseDirectory, "Fonts");
+
+ if (!Directory.Exists(fontsPath))
+ {
+ throw new DirectoryNotFoundException($"Fonts directory not found: {fontsPath}");
+ }
+
+ _fontFolders = new List { fontsPath };
+ }
+
+ [Benchmark]
+ public OpenTypeFont Load_Roboto_Regular_ColdCache()
+ {
+ OpenTypeFonts.ClearFontCache(); // Clear INNE i benchmark
+ return OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.Regular);
+ }
+
+ [Benchmark]
+ public OpenTypeFont Load_Roboto_Regular_WarmCache()
+ {
+ // Load UTAN att cleara - använder cache från GlobalSetup eller warmup
+ return OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.Regular);
+ }
+
+ [Benchmark]
+ public OpenTypeFont Load_Roboto_Bold_ColdCache()
+ {
+ OpenTypeFonts.ClearFontCache();
+ return OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.Bold);
+ }
+
+ [Benchmark]
+ public OpenTypeFont Load_Roboto_Italic_ColdCache()
+ {
+ OpenTypeFonts.ClearFontCache();
+ return OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.Italic);
+ }
+
+ [Benchmark]
+ public OpenTypeFont Load_Roboto_BoldItalic_ColdCache()
+ {
+ OpenTypeFonts.ClearFontCache();
+ return OpenTypeFonts.GetFontData(_fontFolders, "Roboto", FontSubFamily.BoldItalic);
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/EPPlus.Fonts.OpenType.Benchmarks/Fonts/Roboto-Regular.ttf b/src/EPPlus.Fonts.OpenType.Benchmarks/Fonts/Roboto-Regular.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..ddf4bfacb396e97546364ccfeeb9c31dfaea4c25
GIT binary patch
literal 168260
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