Implemented font-fallback as required configuration

Fix documentation link for previewer

QuestPDF.Examples/QuestPDF.Examples.csproj

@@ -6,11 +6,11 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
+        <PackageReference Include="BenchmarkDotNet" Version="0.13.2" />
         <PackageReference Include="microcharts" Version="0.9.5.9" />
-        <PackageReference Include="nunit" Version="3.13.2" />
-        <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
+        <PackageReference Include="nunit" Version="3.13.3" />
+        <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.1" />
         <PackageReference Include="SkiaSharp" Version="2.80.4" />
         <PackageReference Include="Svg.Skia" Version="0.5.10" />
     </ItemGroup>

QuestPDF.Examples/TextExamples.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using System.Text;
 using NUnit.Framework;
+using QuestPDF.Elements.Text;
 using QuestPDF.Examples.Engine;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
@@ -618,5 +619,43 @@ namespace QuestPDF.Examples
                         .FontSize(20);
                 });
         }
+        
+        [Test]
+        public void FontFallback()
+        {
+            RenderingTest
+                .Create()
+                .ProduceImages()
+                .ShowResults()
+                .RenderDocument(container =>
+                {
+                    container.Page(page =>
+                    {
+                        page.Margin(50);
+                        page.PageColor(Colors.White);
+                        page.DefaultTextStyle(x => x
+                            .Fallback(y => y.FontFamily("Segoe UI Emoji")
+                                .Fallback(y => y.FontFamily("Microsoft YaHei"))));
+
+                        page.Size(PageSizes.A4);
+
+                        page.Content().Text(t =>
+                        {
+                            t.Line("This is normal text.");
+                            t.EmptyLine();
+                            
+                            t.Line("Following line should use font fallback:");
+                            t.Line("中文文本");
+                            t.EmptyLine();
+                            
+                            t.Line("The following line contains a mix of known and unknown characters.");
+                            t.Line("Mixed line: This 中文 is 文文 a mixed 本 本 line 本 中文文本!");
+                            t.EmptyLine();
+
+                            t.Line("Emojis work out of the box because of font fallback: 😊😅🥳👍❤😍👌");
+                        });
+                    });
+                });
+        }
     }
 }

QuestPDF.Previewer/PreviewerWindowViewModel.cs

@@ -49,7 +49,7 @@ namespace QuestPDF.Previewer
             CommunicationService.Instance.OnDocumentRefreshed += HandleUpdatePreview;
             
             ShowPdfCommand = ReactiveCommand.Create(ShowPdf);
-            ShowDocumentationCommand = ReactiveCommand.Create(() => OpenLink("https://www.questpdf.com/documentation/api-reference.html"));
+            ShowDocumentationCommand = ReactiveCommand.Create(() => OpenLink("https://www.questpdf.com/api-reference/index.html"));
             SponsorProjectCommand = ReactiveCommand.Create(() => OpenLink("https://github.com/sponsors/QuestPDF"));
         }
 

QuestPDF.ReportSample/PerformanceTests.cs

@@ -51,7 +51,7 @@ namespace QuestPDF.ReportSample
             Content = documentContainer.Compose();
 
             PageContext = new PageContext();
-            DocumentGenerator.RenderPass(PageContext, new FreeCanvas(), Content, Metadata, null);
+            DocumentGenerator.RenderPass(PageContext, new FreeCanvas(), Content, null);
 
             var sw = new Stopwatch();
             sw.Start();
@@ -69,7 +69,7 @@ namespace QuestPDF.ReportSample
         [Benchmark]
         public void GenerationTest()
         {
-            DocumentGenerator.RenderPass(PageContext, new FreeCanvas(), Content, Metadata, null);
+            DocumentGenerator.RenderPass(PageContext, new FreeCanvas(), Content, null);
         }
     }
 }

QuestPDF.ReportSample/Tests.cs

@@ -48,11 +48,10 @@ namespace QuestPDF.ReportSample
             Report.Compose(container);
             var content = container.Compose();
             
-            var metadata = Report.GetMetadata();
             var pageContext = new PageContext();
 
-            DocumentGenerator.RenderPass(pageContext, new FreeCanvas(), content, metadata, null);
-            DocumentGenerator.RenderPass(pageContext, new FreeCanvas(), content, metadata, null);
+            DocumentGenerator.RenderPass(pageContext, new FreeCanvas(), content, null);
+            DocumentGenerator.RenderPass(pageContext, new FreeCanvas(), content, null);
         }
     }
 }

QuestPDF.UnitTests/QuestPDF.UnitTests.csproj

@@ -6,7 +6,7 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="FluentAssertions" Version="6.1.0" />
+        <PackageReference Include="FluentAssertions" Version="6.7.0" />
         <PackageReference Include="nunit" Version="3.13.2" />
         <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.0" />

QuestPDF/Drawing/DocumentGenerator.cs

@@ -66,19 +66,17 @@ namespace QuestPDF.Drawing
             var content = container.Compose();
             ApplyDefaultTextStyle(content, TextStyle.LibraryDefault);
             
-            var metadata = document.GetMetadata();
-            var pageContext = new PageContext();
-
-            var debuggingState = metadata.ApplyDebugging ? ApplyDebugging(content) : null;
+            var debuggingState = Settings.EnableDebugging ? ApplyDebugging(content) : null;
             
-            if (metadata.ApplyCaching)
+            if (Settings.EnableCaching)
                 ApplyCaching(content);
 
-            RenderPass(pageContext, new FreeCanvas(), content, metadata, debuggingState);
-            RenderPass(pageContext, canvas, content, metadata, debuggingState);
+            var pageContext = new PageContext();
+            RenderPass(pageContext, new FreeCanvas(), content, debuggingState);
+            RenderPass(pageContext, canvas, content, debuggingState);
         }
         
-        internal static void RenderPass<TCanvas>(PageContext pageContext, TCanvas canvas, Container content, DocumentMetadata documentMetadata, DebuggingState? debuggingState)
+        internal static void RenderPass<TCanvas>(PageContext pageContext, TCanvas canvas, Container content, DebuggingState? debuggingState)
             where TCanvas : ICanvas, IRenderingCanvas
         {
             content.VisitChildren(x => x?.Initialize(pageContext, canvas));
@@ -114,7 +112,7 @@ namespace QuestPDF.Drawing
 
                 canvas.EndPage();
 
-                if (currentPage >= documentMetadata.DocumentLayoutExceptionThreshold)
+                if (currentPage >= Settings.DocumentLayoutExceptionThreshold)
                 {
                     canvas.EndDocument();
                     ThrowLayoutException();
@@ -131,8 +129,8 @@ namespace QuestPDF.Drawing
             void ThrowLayoutException()
             {
                 var message = $"Composed layout generates infinite document. This may happen in two cases. " +
-                              $"1) Your document and its layout configuration is correct but the content takes more than {documentMetadata.DocumentLayoutExceptionThreshold} pages. " +
-                              $"In this case, please increase the value {nameof(DocumentMetadata)}.{nameof(DocumentMetadata.DocumentLayoutExceptionThreshold)} property configured in the {nameof(IDocument.GetMetadata)} method. " +
+                              $"1) Your document and its layout configuration is correct but the content takes more than {Settings.DocumentLayoutExceptionThreshold} pages. " +
+                              $"In this case, please increase the value {nameof(QuestPDF)}.{nameof(Settings)}.{nameof(Settings.DocumentLayoutExceptionThreshold)} static property. " +
                               $"2) The layout configuration of your document is invalid. Some of the elements require more space than is provided." +
                               $"Please analyze your documents structure to detect this element and fix its size constraints.";
 

QuestPDF/Drawing/DocumentMetadata.cs

@@ -1,4 +1,5 @@
 using System;
+using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Drawing
 {
@@ -18,14 +19,26 @@ namespace QuestPDF.Drawing
         public DateTime CreationDate { get; set; } = DateTime.Now;
         public DateTime ModifiedDate { get; set; } = DateTime.Now;
 
-        /// <summary>
-        /// If the number of generated pages exceeds this threshold
-        /// (likely due to infinite layout), the exception is thrown.
-        /// </summary>
-        public int DocumentLayoutExceptionThreshold { get; set; } = 250;
+        [Obsolete("This API has been moved since version 2022.9. Please use the QuestPDF.Settings.DocumentLayoutExceptionThreshold static property.")]
+        public int DocumentLayoutExceptionThreshold
+        {
+            get => Settings.DocumentLayoutExceptionThreshold;
+            set => Settings.DocumentLayoutExceptionThreshold = value;
+        }
 
-        public bool ApplyCaching { get; set; } = !System.Diagnostics.Debugger.IsAttached;
-        public bool ApplyDebugging { get; set; } = System.Diagnostics.Debugger.IsAttached;
+        [Obsolete("This API has been moved since version 2022.9. Please use the QuestPDF.Settings.EnableCaching static property.")]
+        public bool ApplyCaching
+        {
+            get => Settings.EnableCaching;
+            set => Settings.EnableCaching = value;
+        }
+        
+        [Obsolete("This API has been moved since version 2022.9. Please use the QuestPDF.Settings.EnableDebugging static property.")]
+        public bool ApplyDebugging
+        {
+            get => Settings.EnableDebugging;
+            set => Settings.EnableDebugging = value;
+        }
 
         public static DocumentMetadata Default => new DocumentMetadata();
     }

QuestPDF/Drawing/Exceptions/DocumentDrawingException.cs

@@ -4,6 +4,11 @@ namespace QuestPDF.Drawing.Exceptions
 {
     public class DocumentDrawingException : Exception
     {
+        internal DocumentDrawingException(string message) : base(message)
+        {
+            
+        }
+        
         internal DocumentDrawingException(string message, Exception inner) : base(message, inner)
         {
             

QuestPDF/Drawing/TextShaper.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using HarfBuzzSharp;
 using QuestPDF.Infrastructure;
 using SkiaSharp;
@@ -9,14 +10,16 @@ namespace QuestPDF.Drawing
     internal class TextShaper
     {
         public const int FontShapingScale = 512;
-     
-        private Font Font { get; }
-        private SKPaint Paint { get; }
         
-        public TextShaper(TextStyle style)
+        private TextStyle TextStyle { get; }
+
+        private SKFont Font => TextStyle.ToFont();
+        private Font ShaperFont => TextStyle.ToShaperFont();
+        private SKPaint Paint => TextStyle.ToPaint();
+
+        public TextShaper(TextStyle textStyle)
         {
-            Font = style.ToShaperFont();
-            Paint = style.ToPaint();
+            TextStyle = textStyle;
         }
 
         public TextShapingResult Shape(string text)
@@ -26,7 +29,7 @@ namespace QuestPDF.Drawing
             PopulateBufferWithText(buffer, text);
             buffer.GuessSegmentProperties();
 
-            Font.Shape(buffer);
+            ShaperFont.Shape(buffer);
             
             var length = buffer.Length;
             var glyphInfos = buffer.GlyphInfos;
@@ -52,6 +55,9 @@ namespace QuestPDF.Drawing
                 xOffset += glyphPositions[i].XAdvance * scaleX;
                 yOffset += glyphPositions[i].YAdvance * scaleY;
             }
+
+            if (Settings.CheckIfAllTextGlyphsAreAvailableInSpecifiedFont)
+                CheckIfAllGlyphsAreAvailable(glyphs, text);
             
             return new TextShapingResult(glyphs);
         }
@@ -72,6 +78,20 @@ namespace QuestPDF.Drawing
             else
                 throw new NotSupportedException("TextEncoding of type GlyphId is not supported.");
         }
+        
+        void CheckIfAllGlyphsAreAvailable(ShapedGlyph[] glyphs, string originalText)
+        {
+            var containsMissingGlyphs = glyphs.Any(x => x.Codepoint == default);
+            
+            if (!containsMissingGlyphs)
+                return;
+            
+            throw new ArgumentException(
+                $"Detected missing font glyphs while rendering text. " +
+                $"This means that the document contains text with characters not present in the assigned font. " +
+                $"Such characters are replaced by placeholders, usually visible as empty rectangles. " +
+                $"Font family used: {TextStyle.FontFamily}. Issue detected in text: '{originalText}'");
+        }
     }
     
     internal struct ShapedGlyph

QuestPDF/Elements/Text/Calculation/TextMeasurementResult.cs

@@ -19,6 +19,5 @@ namespace QuestPDF.Elements.Text.Calculation
         public int TotalIndex { get; set; }
 
         public bool IsLast => EndIndex == TotalIndex;
-        public bool IsNewLine { get; set; }
     }
 }

QuestPDF/Elements/Text/FontFallback.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuestPDF.Drawing;
+using QuestPDF.Drawing.Exceptions;
+using QuestPDF.Elements.Text.Items;
+using QuestPDF.Fluent;
+using QuestPDF.Infrastructure;
+using SkiaSharp;
+
+namespace QuestPDF.Elements.Text
+{
+    internal static class FontFallback
+    {
+        public struct TextRun
+        {
+            public string Content { get; set; }
+            public TextStyle Style { get; set; }
+        }
+
+        public class FallbackOption
+        {
+            public TextStyle Style { get; set; }
+            public SKFont Font { get; set; }
+            public SKTypeface Typeface { get; set; }
+        }
+
+        private static SKFontManager FontManager => SKFontManager.Default;
+
+        public static IEnumerable<TextRun> SplitWithFontFallback(this string text, TextStyle textStyle)
+        {
+            var fallbackOptions = GetFallbackOptions(textStyle).ToArray();
+            
+            var spanStartIndex = 0;
+            var spanFallbackOption = fallbackOptions[0];
+            
+            for (var i = 0; i < text.Length; i += char.IsSurrogatePair(text, i) ? 2 : 1)
+            {
+                var codepoint = char.ConvertToUtf32(text, i);
+                var newFallbackOption = MatchFallbackOption(fallbackOptions, codepoint);
+
+                if (newFallbackOption == spanFallbackOption)
+                    continue;
+
+                yield return new TextRun
+                {
+                    Content = text.Substring(spanStartIndex, i - spanStartIndex),
+                    Style = spanFallbackOption.Style
+                };
+
+                spanStartIndex = i;
+                spanFallbackOption = newFallbackOption;
+            }
+            
+            if (spanStartIndex > text.Length)
+                yield break;
+            
+            yield return new TextRun
+            {
+                Content = text.Substring(spanStartIndex, text.Length - spanStartIndex),
+                Style = spanFallbackOption.Style
+            };
+
+            static IEnumerable<FallbackOption> GetFallbackOptions(TextStyle? textStyle)
+            {
+                while (textStyle != null)
+                {
+                    var font = textStyle.ToFont();
+                    
+                    yield return new FallbackOption
+                    {
+                        Style = textStyle,
+                        Font = font,
+                        Typeface = font.Typeface
+                    };
+
+                    textStyle = textStyle.Fallback;
+                }
+            }
+
+            static FallbackOption MatchFallbackOption(ICollection<FallbackOption> fallbackOptions, int codepoint)
+            {
+                foreach (var fallbackOption in fallbackOptions)
+                {
+                    if (fallbackOption.Font.ContainsGlyph(codepoint))
+                        return fallbackOption;
+                }
+                
+                var character = char.ConvertFromUtf32(codepoint);
+                var unicode = $"U-{codepoint:X4}";
+
+
+                var proposedFonts = FindFontsContainingGlyph(codepoint);
+                var proposedFontsFormatted = proposedFonts.Any() ? string.Join(", ", proposedFonts) : "no fonts available";
+                
+                throw new DocumentDrawingException(
+                    $"Could not find an appropriate font fallback for glyph: {unicode} '{character}'. " +
+                    $"Font families available on current environment that contain this glyph: {proposedFontsFormatted}. " +
+                    $"Possible solutions: " +
+                    $"1) Use one of the listed fonts as the primary font in your document. " +
+                    $"2) Configure the fallback TextStyle using the 'TextStyle.Fallback' method with one of the listed fonts. ");
+            }
+
+            static IEnumerable<string> FindFontsContainingGlyph(int codepoint)
+            {
+                var fontManager = SKFontManager.Default;
+
+                return fontManager
+                    .GetFontFamilies()
+                    .Select(fontManager.MatchFamily)
+                    .Where(x => x.ContainsGlyph(codepoint))
+                    .Select(x => x.FamilyName);
+            }
+        }
+
+        public static IEnumerable<ITextBlockItem> ApplyFontFallback(this ICollection<ITextBlockItem> textBlockItems)
+        {
+            foreach (var textBlockItem in textBlockItems)
+            {
+                if (textBlockItem is TextBlockSpan textBlockSpan)
+                {
+                    // perform font-fallback operation only when any fallback is available
+                    if (textBlockSpan.Style.Fallback == null)
+                    {
+                        yield return textBlockSpan;
+                        continue;
+                    }
+                    
+                    var textRuns = textBlockSpan.Text.SplitWithFontFallback(textBlockSpan.Style);
+
+                    foreach (var textRun in textRuns)
+                    {
+                        yield return new TextBlockSpan
+                        {
+                            Text = textRun.Content,
+                            Style = textRun.Style
+                        };
+                    }
+                }
+                else
+                {
+                    yield return textBlockItem;
+                }
+            }
+        }
+    }
+}

QuestPDF/Elements/Text/Items/TextBlockSpan.cs

@@ -15,7 +15,7 @@ namespace QuestPDF.Elements.Text.Items
     {
         public string Text { get; set; }
         public TextStyle Style { get; set; } = new();
-        public TextShapingResult? TextShapingResult { get; set; }
+        private TextShapingResult? TextShapingResult { get; set; }
 
         private Dictionary<(int startIndex, float availableWidth), TextMeasurementResult?> MeasureCache = new ();
         protected virtual bool EnableTextCache => true; 
@@ -39,34 +39,18 @@ namespace QuestPDF.Elements.Text.Items
             
             var paint = Style.ToPaint();
             var fontMetrics = Style.ToFontMetrics();
+            var spaceCodepoint = paint.ToFont().Typeface.GetGlyphs(" ")[0];
 
-            // if the element is the first one within the line,
-            // ignore leading spaces and new lines
-            var spaceCodepoint = paint.ToFont().Typeface.GetGlyph(' ');
-            var newLineCodepoint = paint.ToFont().Typeface.GetGlyph('\n');
-            var returnCodepoint = paint.ToFont().Typeface.GetGlyph('\r');
-            
             var startIndex = request.StartIndex;
             
+            // if the element is the first one within the line,
+            // ignore leading spaces
             if (!request.IsFirstElementInBlock && request.IsFirstElementInLine)
             {
-                while (startIndex < TextShapingResult.Glyphs.Length && (Text[startIndex] == spaceCodepoint || Text[startIndex] == newLineCodepoint || Text[startIndex] == returnCodepoint))
+                while (startIndex < TextShapingResult.Glyphs.Length && Text[startIndex] == spaceCodepoint)
                     startIndex++;
             }
 
-            // calculate max index (new new line)
-            var newLineIndex = startIndex;
-
-            while (newLineIndex < TextShapingResult.Glyphs.Length)
-            {
-                var glyphCodepoint = TextShapingResult.Glyphs[newLineIndex].Codepoint;
-                
-                if (glyphCodepoint == newLineCodepoint || glyphCodepoint == returnCodepoint)
-                    break;
-
-                newLineIndex++;
-            }
-            
             if (TextShapingResult.Glyphs.Length == 0 || startIndex == TextShapingResult.Glyphs.Length)
             {
                 return new TextMeasurementResult
@@ -84,8 +68,6 @@ namespace QuestPDF.Elements.Text.Items
 
             if (endIndex < startIndex)
                 return null;
-
-            endIndex = Math.Min(endIndex, newLineIndex);
   
             // break text only on spaces
             var wrappedText = WrapText(startIndex, endIndex, request.IsFirstElementInLine);
@@ -108,9 +90,7 @@ namespace QuestPDF.Elements.Text.Items
                 StartIndex = startIndex,
                 EndIndex = wrappedText.Value.endIndex,
                 NextIndex = wrappedText.Value.nextIndex,
-                TotalIndex = TextShapingResult.Glyphs.Length - 1,
-                
-                IsNewLine = endIndex == newLineIndex
+                TotalIndex = TextShapingResult.Glyphs.Length - 1
             };
         }
         

QuestPDF/Elements/Text/TextBlock.cs

@@ -11,16 +11,18 @@ namespace QuestPDF.Elements.Text
     internal class TextBlock : Element, IStateResettable
     {
         public HorizontalAlignment Alignment { get; set; } = HorizontalAlignment.Left;
-        public List<ITextBlockItem> Items { get; set; } = new();
-        public float ParagraphSpacing { get; set; } = 0;
+        public List<ITextBlockItem> Items { get; set; } = new List<ITextBlockItem>();
 
         public string Text => string.Join(" ", Items.Where(x => x is TextBlockSpan).Cast<TextBlockSpan>().Select(x => x.Text));
 
         private Queue<ITextBlockItem> RenderingQueue { get; set; }
         private int CurrentElementIndex { get; set; }
 
+        private bool FontFallbackApplied { get; set; } = false;
+        
         public void ResetState()
         {
+            ApplyFontFallback();
             InitializeQueue();
             CurrentElementIndex = 0;
 
@@ -38,6 +40,15 @@ namespace QuestPDF.Elements.Text
                 foreach (var item in Items)
                     RenderingQueue.Enqueue(item);
             }
+
+            void ApplyFontFallback()
+            {
+                if (FontFallbackApplied)
+                    return;
+
+                Items = Items.ApplyFontFallback().ToList();
+                FontFallbackApplied = true;
+            }
         }
 
         internal override SpacePlan Measure(Size availableSpace)
@@ -111,12 +122,6 @@ namespace QuestPDF.Elements.Text
                 Canvas.Translate(new Position(0, line.LineHeight));
                 
                 heightOffset += line.LineHeight;
-
-                if (line.Elements.Last().Measurement.IsNewLine)
-                {
-                    heightOffset += ParagraphSpacing;
-                    Canvas.Translate(new Position(0, ParagraphSpacing));
-                }
             }
             
             Canvas.Translate(new Position(0, -heightOffset));

QuestPDF/Fluent/TextExtensions.cs

@@ -40,9 +40,10 @@ namespace QuestPDF.Fluent
     
     public class TextDescriptor
     {
-        internal TextBlock TextBlock = new();
+        private ICollection<TextBlock> TextBlocks { get; } = new List<TextBlock>();
         private TextStyle DefaultStyle { get; set; } = TextStyle.Default;
         internal HorizontalAlignment Alignment { get; set; } = HorizontalAlignment.Left;
+        private float Spacing { get; set; } = 0f;
 
         public void DefaultTextStyle(TextStyle style)
         {
@@ -71,9 +72,17 @@ namespace QuestPDF.Fluent
 
         public void ParagraphSpacing(float value, Unit unit = Unit.Point)
         {
-            TextBlock.ParagraphSpacing = value.ToPoints(unit);
+            Spacing = value.ToPoints(unit);
         }
 
+        private void AddItemToLastTextBlock(ITextBlockItem item)
+        {
+            if (!TextBlocks.Any())
+                TextBlocks.Add(new TextBlock());
+            
+            TextBlocks.Last().Items.Add(item);
+        }
+        
         [Obsolete("This element has been renamed since version 2022.3. Please use the overload that returns a TextSpanDescriptor object which allows to specify text style.")]
         public void Span(string? text, TextStyle style)
         {
@@ -87,13 +96,28 @@ namespace QuestPDF.Fluent
 
             if (text == null)
                 return descriptor;
-            
-            TextBlock.Items.Add(new TextBlockSpan
-            {
-                Text = text,
-                Style = style
-            });
-            
+ 
+            var items = text
+                .Replace("\r", string.Empty)
+                .Split(new[] { '\n' }, StringSplitOptions.None)
+                .Select(x => new TextBlockSpan
+                {
+                    Text = x,
+                    Style = style
+                })
+                .ToList();
+
+            AddItemToLastTextBlock(items.First());
+
+            items
+                .Skip(1)
+                .Select(x => new TextBlock
+                {   
+                    Items = new List<ITextBlockItem> { x }
+                })
+                .ToList()
+                .ForEach(TextBlocks.Add);
+
             return descriptor;
         }
 
@@ -113,7 +137,7 @@ namespace QuestPDF.Fluent
             var style = DefaultStyle.Clone();
             var descriptor = new TextPageNumberDescriptor(style);
             
-            TextBlock.Items.Add(new TextBlockPageNumber
+            AddItemToLastTextBlock(new TextBlockPageNumber
             {
                 Source = context => descriptor.FormatFunction(pageNumber(context)),
                 Style = style
@@ -169,7 +193,7 @@ namespace QuestPDF.Fluent
             if (IsNullOrEmpty(text))
                 return descriptor;
             
-            TextBlock.Items.Add(new TextBlockSectionLink
+            AddItemToLastTextBlock(new TextBlockSectionLink
             {
                 Style = style,
                 Text = text,
@@ -196,7 +220,7 @@ namespace QuestPDF.Fluent
             if (IsNullOrEmpty(text))
                 return descriptor;
             
-            TextBlock.Items.Add(new TextBlockHyperlink
+            AddItemToLastTextBlock(new TextBlockHyperlink
             {
                 Style = style,
                 Text = text,
@@ -216,13 +240,33 @@ namespace QuestPDF.Fluent
         {
             var container = new Container();
                 
-            TextBlock.Items.Add(new TextBlockElement
+            AddItemToLastTextBlock(new TextBlockElement
             {
                 Element = container
             });
             
             return container.AlignBottom().MinimalBox();
         }
+        
+        internal void Compose(IContainer container)
+        {
+            TextBlocks.ToList().ForEach(x => x.Alignment = Alignment);
+            container = container.DefaultTextStyle(DefaultStyle);
+
+            if (TextBlocks.Count == 1)
+            {
+                container.Element(TextBlocks.First());
+                return;
+            }
+            
+            container.Column(column =>
+            {
+                column.Spacing(Spacing);
+
+                foreach (var textBlock in TextBlocks)
+                    column.Item().Element(textBlock);
+            }); 
+        }
     }
     
     public static class TextExtensions
@@ -235,7 +279,7 @@ namespace QuestPDF.Fluent
                 descriptor.Alignment = alignment.Horizontal;
             
             content?.Invoke(descriptor);
-            element.Element(descriptor.TextBlock);
+            descriptor.Compose(element);
         }
         
         [Obsolete("This element has been renamed since version 2022.3. Please use the overload that returns a TextSpanDescriptor object which allows to specify text style.")]

QuestPDF/Fluent/TextSpanDescriptorExtensions.cs

@@ -15,6 +15,17 @@ namespace QuestPDF.Fluent
             return descriptor;
         }
         
+        public static T Fallback<T>(this T descriptor, TextStyle? value = null) where T : TextSpanDescriptor
+        {
+            descriptor.TextStyle.Fallback = value;
+            return descriptor;
+        }
+        
+        public static T Fallback<T>(this T descriptor, Func<TextStyle, TextStyle> handler) where T : TextSpanDescriptor
+        {
+            return descriptor.Fallback(handler(TextStyle.Default));
+        }
+        
         public static T FontColor<T>(this T descriptor, string value) where T : TextSpanDescriptor
         {
             descriptor.TextStyle.Color = value;

QuestPDF/Fluent/TextStyleExtensions.cs

@@ -14,6 +14,16 @@ namespace QuestPDF.Fluent
             return style;
         }
         
+        public static TextStyle Fallback(this TextStyle style, TextStyle? value = null)
+        {
+            return style.Mutate(x => x.Fallback = value);
+        }
+        
+        public static TextStyle Fallback(this TextStyle style, Func<TextStyle, TextStyle> handler)
+        {
+            return style.Fallback(handler(TextStyle.Default));
+        }
+        
         [Obsolete("This element has been renamed since version 2022.3. Please use the FontColor method.")]
         public static TextStyle Color(this TextStyle style, string value)
         {

QuestPDF/Infrastructure/TextStyle.cs

@@ -1,4 +1,5 @@
 using System;
+using HarfBuzzSharp;
 using QuestPDF.Helpers;
 
 namespace QuestPDF.Infrastructure
@@ -19,12 +20,12 @@ namespace QuestPDF.Infrastructure
         internal bool? HasUnderline { get; set; }
         internal bool? WrapAnywhere { get; set; }
 
-        internal object PaintKey { get; private set; }
-        internal object FontMetricsKey { get; private set; }
+        internal TextStyle? Fallback { get; set; }
+        
+        // TODO: without cache, this may be an expensive operation
+        internal object PaintKey => (FontFamily, Size, FontWeight, FontPosition, IsItalic, Color);
+        internal object FontMetricsKey => (FontFamily, Size, FontWeight, IsItalic);
         
-        // REVIEW: Should this be a method call that news up a TextStyle,
-        // or can it be a static variable?
-        // (style mutations seem to create a clone anyway)
         internal static readonly TextStyle LibraryDefault = new TextStyle
         {
             Color = Colors.Black,
@@ -37,7 +38,8 @@ namespace QuestPDF.Infrastructure
             IsItalic = false,
             HasStrikethrough = false,
             HasUnderline = false,
-            WrapAnywhere = false
+            WrapAnywhere = false,
+            Fallback = null
         };
 
         // it is important to create new instances for the DefaultTextStyle element to work correctly
@@ -49,13 +51,19 @@ namespace QuestPDF.Infrastructure
                 return;
             
             HasGlobalStyleApplied = true;
-
             ApplyParentStyle(globalStyle);
-            PaintKey ??= (FontFamily, Size, FontWeight, FontPosition, IsItalic, Color);
-            FontMetricsKey ??= (FontFamily, Size, FontWeight, IsItalic);
+
+            if (Fallback != null)
+                ApplyFallbackStyle(this);
+        }
+
+        internal void ApplyFallbackStyle(TextStyle parentStyle)
+        {
+            ApplyParentStyle(parentStyle, false);
+            Fallback?.ApplyFallbackStyle(this);
         }
         
-        internal void ApplyParentStyle(TextStyle parentStyle)
+        internal void ApplyParentStyle(TextStyle parentStyle, bool mapFallback = true)
         {
             Color ??= parentStyle.Color;
             BackgroundColor ??= parentStyle.BackgroundColor;
@@ -68,6 +76,9 @@ namespace QuestPDF.Infrastructure
             HasStrikethrough ??= parentStyle.HasStrikethrough;
             HasUnderline ??= parentStyle.HasUnderline;
             WrapAnywhere ??= parentStyle.WrapAnywhere;
+            
+            if (mapFallback)
+                Fallback ??= parentStyle.Fallback?.Clone();
         }
 
         internal void OverrideStyle(TextStyle parentStyle)
@@ -83,12 +94,14 @@ namespace QuestPDF.Infrastructure
             HasStrikethrough = parentStyle.HasStrikethrough ?? HasStrikethrough;
             HasUnderline = parentStyle.HasUnderline ?? HasUnderline;
             WrapAnywhere = parentStyle.WrapAnywhere ?? WrapAnywhere;
+            Fallback = parentStyle.Fallback?.Clone() ?? Fallback;
         }
         
         internal TextStyle Clone()
         {
             var clone = (TextStyle)MemberwiseClone();
             clone.HasGlobalStyleApplied = false;
+            clone.Fallback = Fallback?.Clone();
             return clone;
         }
     }

QuestPDF/QuestPDF.csproj

@@ -3,7 +3,7 @@
         <Authors>MarcinZiabek</Authors>
         <Company>CodeFlint</Company>
         <PackageId>QuestPDF</PackageId>
-        <Version>2202.8.2</Version>
+        <Version>2022.8.2</Version>
         <PackageDescription>QuestPDF is an open-source, modern and battle-tested library that can help you with generating PDF documents by offering friendly, discoverable and predictable C# fluent API.</PackageDescription>
         <PackageReleaseNotes>$([System.IO.File]::ReadAllText("$(MSBuildProjectDirectory)/Resources/ReleaseNotes.txt"))</PackageReleaseNotes>
         <LangVersion>9</LangVersion>

QuestPDF/Resources/ReleaseNotes.txt

@@ -16,5 +16,5 @@
 - Updated stability of rendering elements in negative space
 - Optimization for the Column element: do not measure child when available height is negative
 
-2202.8.2
+2022.8.2
 - Fixed: the Column element incorrectly renders zero-height elements.

QuestPDF/Settings.cs

@@ -0,0 +1,40 @@
+namespace QuestPDF
+{
+    public static class Settings
+    {
+        /// <summary>
+        /// This value represents the maximum lenght of the document that the library produces.
+        /// This is useful when layout constraints are too strong, e.g. one element does not fit in another.
+        /// In such cases, the library would produce document of infinite length, consuming all available resources.
+        /// To break the algorithm and save the environment, the library breaks the rendering process after reaching specified length of document.
+        /// If your content requires generating longer documents, please assign the most reasonable value.
+        /// </summary>
+        public static int DocumentLayoutExceptionThreshold { get; set; } = 250;
+        
+        /// <summary>
+        /// This flag generates additional document elements to cache layout calculation results.
+        /// In the vast majority of cases, this significantly improves performance, while slightly increasing memory consumption.
+        /// </summary>
+        /// <remarks>By default, this flag is enabled only when the debugger is NOT attached.</remarks>
+        public static bool EnableCaching { get; set; } = !System.Diagnostics.Debugger.IsAttached;
+        
+        /// <summary>
+        /// This flag generates additional document elements to improve layout debugging experience.
+        /// When the DocumentLayoutException is thrown, the library is able to provide additional execution context.
+        /// It includes layout calculation results and path to the problematic area.
+        /// </summary>
+        /// <remarks>By default, this flag is enabled only when the debugger IS attached.</remarks>
+        public static bool EnableDebugging { get; set; } = System.Diagnostics.Debugger.IsAttached;
+        
+        /// <summary>
+        /// This flag enables checking the font glyph availability.
+        /// If your text contains glyphs that are not present in the specified font,
+        /// 1) when this flag is enabled: the DocumentDrawingException is thrown. OR 
+        /// 2) when this flag is disabled: placeholder characters are visible in the produced PDF file. 
+        /// Enabling this flag may slightly decrease document generation performance.
+        /// However, it provides hints that used fonts are not sufficient to produce correct results.
+        /// </summary>
+        /// <remarks>By default, this flag is enabled only when the debugger IS attached.</remarks>
+        public static bool CheckIfAllTextGlyphsAreAvailableInSpecifiedFont { get; set; } = System.Diagnostics.Debugger.IsAttached;
+    }
+}