Big PDF fixes merge.

src/EPPlus.Export.Pdf.Tests/FontTests.cs

@@ -12,6 +12,7 @@ This software is licensed under PolyForm Noncommercial License 1.0.0
 using EPPlus.Export.Pdf.Resources;
 using EPPlus.Export.Pdf.Settings;
 using EPPlus.Fonts.OpenType;
+using EPPlus.Fonts.OpenType.Integration;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using OfficeOpenXml.Interfaces.Fonts;
 using System;
@@ -57,11 +58,33 @@ private static PdfPageSettings CreateSettings(OpenTypeFontEngine engine, bool em
             return settings;
         }
 
-        private static PdfDictionaries CreateDictionariesWithSingleFont(PdfPageSettings settings)
+        private static PdfDictionaries CreateDictionariesWithSingleFont(PdfPageSettings settings, OpenTypeFontEngine engine)
         {
             var dictionaries = new PdfDictionaries();
-            // Register one font with some text so a subset is produced.
-            dictionaries.AddFont(settings, TestFontName, FontSubFamily.Regular, "Hello world!");
+
+            // In the new model Fonts is populated during shaping (ShapeText creates the resource,
+            // GidsAndCharMap fills gids + charmap), NOT by AddFont. Reproduce that end state directly
+            // so AddFontData has a realistic embedded resource to emit, without running a full export.
+            var font = engine.LoadFont(TestFontName, FontSubFamily.Regular);
+            var key = new FontKey(font.GetEnglishFontFamilyName(), font.NameTable.GetSubfamilyEnum());
+
+            var resource = new PdfFontResource(font.GetEnglishFontFamilyName(), font.NameTable.GetSubfamilyEnum(), 1, settings);
+            resource.fontData = font;
+
+            // Populate a few glyphs as shaping would, so the embedded path (CIDSet, font stream subset)
+            // has real glyph ids to work with.
+            ushort gid;
+            foreach (var ch in "Hi")
+            {
+                if (font.CmapTable.TryGetGlyphId(ch, out gid) && gid != 0)
+                {
+                    resource.Gids.Add(gid);
+                    if (!resource.charactermappings.ContainsKey(gid))
+                        resource.charactermappings[gid] = ch.ToString();
+                }
+            }
+
+            dictionaries.Fonts[key] = resource;
             return dictionaries;
         }
 
@@ -77,12 +100,12 @@ public void AddFontData_Embedded_FontResourcePointsAtType0Dict()
             using (var engine = CreateEngine())
             {
                 var settings = CreateSettings(engine, true);
-                var dictionaries = CreateDictionariesWithSingleFont(settings);
+                var dictionaries = CreateDictionariesWithSingleFont(settings, engine);
 
                 var excelPdf = new ExcelPdf();
                 excelPdf.SetPageSettingsForTest(settings);
+                excelPdf.SetDocumentSettingsForTest(PdfDocumentSettings.From(settings));
                 excelPdf.SetDictionariesForTest(dictionaries);
-
                 excelPdf.AddFontData();
 
                 var fontResource = dictionaries.GetFont(settings, TestFontName, FontSubFamily.Regular);
@@ -126,12 +149,12 @@ public void AddFontData_Embedded_DoesNotEmitSimpleFontObject()
             using (var engine = CreateEngine())
             {
                 var settings = CreateSettings(engine, true);
-                var dictionaries = CreateDictionariesWithSingleFont(settings);
+                var dictionaries = CreateDictionariesWithSingleFont(settings, engine);
 
                 var excelPdf = new ExcelPdf();
                 excelPdf.SetPageSettingsForTest(settings);
+                excelPdf.SetDocumentSettingsForTest(PdfDocumentSettings.From(settings));
                 excelPdf.SetDictionariesForTest(dictionaries);
-
                 excelPdf.AddFontData();
 
                 foreach (var obj in excelPdf._document)

src/EPPlus.Export.Pdf.Tests/PdfTestBase.cs

@@ -21,5 +21,28 @@ protected void SaveAsPdf(ExcelWorksheet sheet, string pdfFileName)
             var path = Path.Combine(_pdfPath, pdfFileName);
             sheet.SaveAsPdf(path);
         }
+
+        protected void SaveAsPdf(ExcelWorkbook wb, string pdfFileName)
+        {
+            if (!pdfFileName.ToLower().EndsWith(".pdf"))
+            {
+                pdfFileName += ".pdf";
+            }
+            var path = Path.Combine(_pdfPath, pdfFileName);
+            wb.SaveAsPdf(path);
+        }
+
+        protected void SaveAsPdf(ExcelWorkbook wb, string pdfFileName, params ExcelRangeBase[] ranges)
+        {
+            if (!pdfFileName.ToLower().EndsWith(".pdf"))
+            {
+                pdfFileName += ".pdf";
+            }
+            var path = Path.Combine(_pdfPath, pdfFileName);
+            if (ranges.Count() > 1)
+                wb.SaveAsPdf(path, ranges);
+            else
+                ranges[0].SaveAsPdf(path);
+        }
     }
 }

src/EPPlus.Export.Pdf.Tests/PdfTests.cs

@@ -11,10 +11,14 @@ Date               Author                       Change
   10/07/2025         EPPlus Software AB           EPPlus.Fonts.OpenType 1.0
  *************************************************************************************************/
 using EPPlus.Export.Pdf.Settings;
-using EPPlus.Export.Pdf.Tests;
 using EPPlus.Export.Pdf.Settings.PdfPageSizes;
+using EPPlus.Export.Pdf.Tests;
 using OfficeOpenXml;
 using OfficeOpenXml.Export.PdfExport;
+using OfficeOpenXml.Interfaces.Fonts;
+using OfficeOpenXml.Export.PdfExport.Data;
+using OfficeOpenXml.Export.PdfExport.Layout;
+using OfficeOpenXml.FormulaParsing.Excel.Functions.Information;
 using OfficeOpenXml.Export.PdfExport.Settings;
 using OfficeOpenXml.Style;
 using System.Diagnostics;
@@ -506,6 +510,116 @@ public void SaveRangeToNonWritableStreamThrowsTest()
             Assert.ThrowsExactly<ArgumentException>(() => range.SaveAsPdf(readOnly));
         }
 
+        [TestMethod]
+        public void ThreeFonts_NoSkip_RendersAllThreeCorrectly()
+        {
+            // Baseline: three different fonts, no skipping. Verifies the normal path still works
+            // after the subsetting rewrite. Open the PDF and confirm A1/B1/C1 read correctly.
+            using var p = OpenPackage("ThreeFonts_NoSkip.xlsx", true);
+            var ws = p.Workbook.Worksheets.Add("Sheet1");
+
+            ws.Cells["A1"].Style.Font.Name = "Aptos Narrow";
+            ws.Cells["A1"].Value = "A1";
+            ws.Cells["B1"].Style.Font.Name = "Times New Roman";
+            ws.Cells["B1"].Value = "B1";
+            ws.Cells["C1"].Style.Font.Name = "Arial";
+            ws.Cells["C1"].Value = "C1";
+
+            SaveAsPdf(ws, "ThreeFonts_NoSkip.pdf");
+        }
+
+        [TestMethod]
+        public void MultiSheetWorkbook()
+        {
+            // Baseline: three different fonts, no skipping. Verifies the normal path still works
+            // after the subsetting rewrite. Open the PDF and confirm A1/B1/C1 read correctly.
+            using var p = OpenPackage("MultiSheetWorkbook.xlsx", true);
+            p.Workbook.ConfigureFonts(x => x.SearchSystemDirectories = true);
+            var ws = p.Workbook.Worksheets.Add("Sheet1");
+
+            ws.Cells["A1"].Value = "Sheet1:A1";
+
+            var ws2 = p.Workbook.Worksheets.Add("Sheet2");
+
+            ws2.Cells["A1"].Style.Font.Name = "Times New Roman";
+            ws2.Cells["A1"].Value = "Sheet2:A1";
+
+            SaveAsPdf(p.Workbook, "MultiSheetWorkbook.pdf");
+        }
+
+        [TestMethod]
+        public void MultiRanges()
+        {
+            // Baseline: three different fonts, no skipping. Verifies the normal path still works
+            // after the subsetting rewrite. Open the PDF and confirm A1/B1/C1 read correctly.
+            using var p = OpenPackage("MultiRanges.xlsx", true);
+            p.Workbook.ConfigureFonts(x => x.SearchSystemDirectories = true);
+            var ws = p.Workbook.Worksheets.Add("Sheet1");
+
+            ws.Cells["A1"].Value = "Sheet1:A1";
+            ws.Cells["F100"].Value = "Sheet1:F100";
+
+            SaveAsPdf(p.Workbook, "MultiRanges.pdf", ws.Cells["A1"], ws.Cells["F100"]);
+        }
+
+        [TestMethod]
+        public void SingleRange()
+        {
+            // Baseline: three different fonts, no skipping. Verifies the normal path still works
+            // after the subsetting rewrite. Open the PDF and confirm A1/B1/C1 read correctly.
+            using var p = OpenPackage("SingleRange.xlsx", true);
+            p.Workbook.ConfigureFonts(x => x.SearchSystemDirectories = true);
+            var ws = p.Workbook.Worksheets.Add("Sheet1");
+
+            ws.Cells["A1"].Value = "Sheet1:A1";
+
+            SaveAsPdf(p.Workbook, "SingleRange.pdf", ws.Cells["A1"]);
+        }
+
+        [TestMethod]
+        public void ArialBlack_RendersCorrectly()
+        {
+            // Baseline: three different fonts, no skipping. Verifies the normal path still works
+            // after the subsetting rewrite. Open the PDF and confirm A1/B1/C1 read correctly.
+            using var p = OpenPackage("ArialBlack.xlsx", true);
+            var ws = p.Workbook.Worksheets.Add("Sheet1");
+
+            ws.Cells["A1"].Style.Font.Name = "Arial Black";
+            ws.Cells["A1"].Value = "A1";
+
+            SaveAsPdf(ws, "ArialBlack.pdf");
+        }
+
+        [TestMethod]
+        public void ThreeFonts_SkipAll_CollapseToSharedLastResort()
+        {
+            // The regression case: three fonts, all skipped via OnFontEmbedding. Expected AFTER the fix:
+            //   - small PDF (one shared Archivo subset, not three whole fonts)
+            //   - A1 / B1 / C1 render DISTINCTLY and correctly (not all "A1")
+            //   - the PDF opens without corruption
+            using var p = OpenPackage("ThreeFonts_SkipAll.xlsx", true);
+            var ws = p.Workbook.Worksheets.Add("Sheet1");
+
+            ws.Cells["A1"].Style.Font.Name = "Aptos Narrow";
+            ws.Cells["A1"].Value = "A1";
+            ws.Cells["B1"].Style.Font.Name = "Times New Roman";
+            ws.Cells["B1"].Value = "B1";
+            ws.Cells["C1"].Style.Font.Name = "Arial";
+            ws.Cells["C1"].Value = "C1";
+
+            p.Workbook.ConfigureFonts(cfg =>
+            {
+                cfg.OnFontEmbedding(info =>
+                {
+                    System.Diagnostics.Debug.WriteLine("OnFontEmbedding fired for: " + info.FontName);
+                    return FontEmbeddingDecision.Skip;
+                });
+            });
+
+
+            SaveAsPdf(ws, "ThreeFonts_SkipAll.pdf");
+        }
+
         [TestMethod]
         // works as expected.
         //[DataRow("PDFTest.xlsx", "C:\\epplustest\\pdf\\FullPageTest56.pdf", "Sheet1")]
@@ -761,5 +875,61 @@ public void EachWorksheetUsesItsOwnPaperSize()
             }
         }
 
+        [TestMethod]
+        public void HeaderFooterTest1()
+        {
+            using var p = OpenTemplatePackage("1.06-Salesreport.xlsx");
+            var ws = p.Workbook.Worksheets[0];
+            string path = _pdfPath + "HeaderFooterTest1.pdf";
+            ws.SaveAsPdf(path);
+            Assert.IsTrue(File.Exists(path), "PDF file was not created.");
+            AssertLooksLikePdf(File.ReadAllBytes(path));
+        }
+
+        [TestMethod]
+        public void GetOriginX_CenteringOff_ReturnsContentBoundsLeft()
+        {
+            var s = new PdfPageSettings(null);
+            var p = new Page()
+            {
+                FromRow = 1,
+                ToRow = 10,
+                FromColumn = 1,
+                ToColumn = 5,
+                UsedWidth = 100,
+                UsedHeight = 100,
+                RowHeights = new double[10]
+            };
+
+            Assert.AreEqual(s.ContentBounds.Left, PdfLayout.GetOriginX(s, p), 0.0001);
+        }
+
+        [TestMethod]
+        public void GetOrigin_FlagsAreIndependent()
+        {
+            var s = new PdfPageSettings(null);
+            s.CenterOnPageHorizontally = true;
+            var p = new Page()
+            {
+                FromRow = 1,
+                ToRow = 10,
+                FromColumn = 1,
+                ToColumn = 5,
+                UsedWidth = s.ContentBounds.Width - 100d,
+                UsedHeight = s.ContentBounds.Height - 200d,
+                RowHeights = new double[10]
+            };
+            Assert.AreEqual(s.ContentBounds.Left + 50d, PdfLayout.GetOriginX(s, p), 0.0001);
+            Assert.AreEqual(s.ContentBounds.Top, PdfLayout.GetOriginY(s, p), 0.0001);
+        }
+
+        [TestMethod]
+        public void GetClampedCellWidth_CellFitsWithinPage_ReturnsCellWidthUnchanged()
+        {
+            var s = new PdfPageSettings(null);
+
+            Assert.AreEqual(51.71d, PdfLayout.GetClampedCellWidth(s, 126.31d, 51.71d), 0.0001);
+        }
+
     }
 }