Fixed preview button labels

Previewer - ViewModel for PreviewerWindow

.editorconfig

@@ -0,0 +1,131 @@
+# Rules in this file were initially inferred by Visual Studio IntelliCode from the D:\GithubRepos\QuestPDF codebase based on best match to current usage at 16.03.2022
+# You can modify the rules from these initially generated values to suit your own policies
+# You can learn more about editorconfig here: https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference
+[*.cs]
+
+
+#Core editorconfig formatting - indentation
+
+#use soft tabs (spaces) for indentation
+indent_style = space
+
+#Formatting - new line options
+
+#place catch statements on a new line
+csharp_new_line_before_catch = true
+#place else statements on a new line
+csharp_new_line_before_else = true
+#require members of anonymous types to be on separate lines
+csharp_new_line_before_members_in_anonymous_types = true
+#require members of object intializers to be on separate lines
+csharp_new_line_before_members_in_object_initializers = true
+#require braces to be on a new line for object_collection_array_initializers, methods, anonymous_types, control_blocks, types, and lambdas (also known as "Allman" style)
+csharp_new_line_before_open_brace =all
+
+#Formatting - organize using options
+
+#sort System.* using directives alphabetically, and place them before other usings
+dotnet_sort_system_directives_first = true
+
+#Formatting - spacing options
+
+#require NO space between a cast and the value
+csharp_space_after_cast = false
+#require a space before the colon for bases or interfaces in a type declaration
+csharp_space_after_colon_in_inheritance_clause = true
+#require a space after a keyword in a control flow statement such as a for loop
+csharp_space_after_keywords_in_control_flow_statements = true
+#require a space before the colon for bases or interfaces in a type declaration
+csharp_space_before_colon_in_inheritance_clause = true
+#remove space within empty argument list parentheses
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+#remove space between method call name and opening parenthesis
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+#do not place space characters after the opening parenthesis and before the closing parenthesis of a method call
+csharp_space_between_method_call_parameter_list_parentheses = false
+#remove space within empty parameter list parentheses for a method declaration
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
+#place a space character after the opening parenthesis and before the closing parenthesis of a method declaration parameter list.
+csharp_space_between_method_declaration_parameter_list_parentheses = false
+
+#Formatting - wrapping options
+
+#leave code block on single line
+csharp_preserve_single_line_blocks = true
+
+#Style - Code block preferences
+
+#prefer no curly braces if allowed
+csharp_prefer_braces = false:suggestion
+
+#Style - expression bodied member options
+
+#prefer block bodies for constructors
+csharp_style_expression_bodied_constructors = false:suggestion
+#prefer block bodies for methods
+csharp_style_expression_bodied_methods = false:suggestion
+#prefer expression-bodied members for properties
+csharp_style_expression_bodied_properties = true:suggestion
+
+#Style - expression level options
+
+#prefer out variables to be declared inline in the argument list of a method call when possible
+csharp_style_inlined_variable_declaration = true:suggestion
+#prefer the language keyword for member access expressions, instead of the type name, for types that have a keyword to represent them
+dotnet_style_predefined_type_for_member_access = true:suggestion
+
+#Style - Expression-level  preferences
+
+#prefer objects to be initialized using object initializers when possible
+dotnet_style_object_initializer = true:suggestion
+#prefer inferred anonymous type member names
+dotnet_style_prefer_inferred_anonymous_type_member_names = false:suggestion
+#prefer inferred tuple element names
+dotnet_style_prefer_inferred_tuple_names = true:suggestion
+
+#Style - implicit and explicit types
+
+#prefer var over explicit type in all cases, unless overridden by another code style rule
+csharp_style_var_elsewhere = true:suggestion
+#prefer var is used to declare variables with built-in system types such as int
+csharp_style_var_for_built_in_types = true:suggestion
+#prefer var when the type is already mentioned on the right-hand side of a declaration expression
+csharp_style_var_when_type_is_apparent = true:suggestion
+
+#Style - language keyword and framework type options
+
+#prefer the language keyword for local variables, method parameters, and class members, instead of the type name, for types that have a keyword to represent them
+dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
+
+#Style - Miscellaneous preferences
+
+#prefer local functions over anonymous functions
+csharp_style_pattern_local_over_anonymous_function = true:suggestion
+
+#Style - modifier options
+
+#prefer accessibility modifiers to be declared except for public interface members. This will currently not differ from always and will act as future proofing for if C# adds default interface methods.
+dotnet_style_require_accessibility_modifiers = for_non_interface_members:suggestion
+
+#Style - Modifier preferences
+
+#when this rule is set to a list of modifiers, prefer the specified ordering.
+csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:silent
+
+#Style - Pattern matching
+
+#prefer pattern matching instead of is expression with type casts
+csharp_style_pattern_matching_over_as_with_null_check = true:suggestion
+
+#Style - qualification options
+
+#prefer fields not to be prefaced with this. or Me. in Visual Basic
+dotnet_style_qualification_for_field = false:suggestion
+#prefer methods not to be prefaced with this. or Me. in Visual Basic
+dotnet_style_qualification_for_method = false:suggestion
+#prefer properties not to be prefaced with this. or Me. in Visual Basic
+dotnet_style_qualification_for_property = false:suggestion
+
+[*.{cs,vb}]
+tab_width=4
+indent_size=4

QuestPDF.Examples/ComplexLayoutBenchmark.cs

@@ -16,7 +16,7 @@ namespace QuestPDF.Examples
                 .PageSize(PageSizes.A4)
                 .ProducePdf()
                 .ShowResults()
-                .Render(x => GenerateStructure(x, 16));
+                .Render(x => GenerateStructure(x, 12));
         }
 
         private void GenerateStructure(IContainer container, int level)

QuestPDF.Examples/DefaultTextStyleExample.cs

@@ -24,7 +24,7 @@ namespace QuestPDF.Examples
                     
                         page.Margin(20);
                         page.Size(PageSizes.A4);
-                        page.Background(Colors.White);
+                        page.PageColor(Colors.White);
         
                         page.Content().Column(column =>
                         {

QuestPDF.Examples/DifferentHeaderOnFirstPageExample.cs

@@ -24,7 +24,7 @@ namespace QuestPDF.Examples
                     {
                         page.Size(PageSizes.A6);
                         page.Margin(5);
-                        page.Background(Colors.White);
+                        page.PageColor(Colors.White);
                         
                         page.Header().Column(column =>
                         {

QuestPDF.Examples/ElementExamples.cs

@@ -742,7 +742,7 @@ namespace QuestPDF.Examples
                 {
                     container
                         .Padding(25)
-                        .PaddingLeft(75)
+                        .PaddingLeft(50)
                         .Column(column =>
                         {
                             column.Item().Width(300).Height(150).Background(Colors.Blue.Lighten4);

QuestPDF.Examples/Engine/RenderingTest.cs

@@ -23,6 +23,8 @@ namespace QuestPDF.Examples.Engine
         private bool ApplyCaching { get; set; }
         private bool ApplyDebugging { get; set; }
         private RenderingTestResult ResultType { get; set; } = RenderingTestResult.Images;
+
+        private bool ShowingResultsEnabled = true;
         
         private RenderingTest()
         {
@@ -114,7 +116,7 @@ namespace QuestPDF.Examples.Engine
                 Func<int, string> fileNameSchema = i => $"{FileNamePrefix}-${i}.png";
                 document.GenerateImages(fileNameSchema);
                 
-                if (ShowResult)
+                if (ShowResult && ShowingResultsEnabled)
                     Process.Start("explorer", fileNameSchema(0));
             }
 
@@ -123,7 +125,7 @@ namespace QuestPDF.Examples.Engine
                 var fileName = $"{FileNamePrefix}.pdf";
                 document.GeneratePdf(fileName);
                 
-                if (ShowResult)
+                if (ShowResult && ShowingResultsEnabled)
                     Process.Start("explorer", fileName);
             }
         }

QuestPDF.Examples/EnsureSpaceExample.cs

@@ -21,7 +21,7 @@ namespace QuestPDF.Examples
                     {
                         page.Margin(20);
                         page.Size(PageSizes.A7.Landscape());
-                        page.Background(Colors.White);
+                        page.PageColor(Colors.White);
                         
                         page.Header().Text("With ensure space").SemiBold();
                         

QuestPDF.Examples/MinimalApiExamples.cs

@@ -19,11 +19,12 @@ namespace QuestPDF.Examples
                     {
                         page.Size(PageSizes.A4);
                         page.Margin(2, Unit.Centimetre);
-                        page.Background(Colors.White);
-                        page.DefaultTextStyle(TextStyle.Default.Size(20));
+                        page.PageColor(Colors.White);
+                        page.DefaultTextStyle(x => x.FontSize(20));
                         
                         page.Header()
-                            .Text("Hello PDF!").SemiBold().FontSize(36).FontColor(Colors.Blue.Medium);
+                            .Text("Hello PDF!")
+                            .SemiBold().FontSize(36).FontColor(Colors.Blue.Medium);
                         
                         page.Content()
                             .PaddingVertical(1, Unit.Centimetre)
@@ -48,48 +49,5 @@ namespace QuestPDF.Examples
 
             Process.Start("explorer.exe", "hello.pdf");
         }
-        
-        [Test]
-        public void MinimalApi2()
-        {
-            RenderingTest
-                .Create()
-                .ProduceImages()
-                .ShowResults()
-                .RenderDocument(container =>
-                {
-                    container.Page(page =>
-                    {
-                        page.Size(PageSizes.A4);
-                        page.Margin(2, Unit.Centimetre);
-                        page.Background(Colors.White);
-                        page.DefaultTextStyle(TextStyle.Default.Size(20));
-                        
-                        page.Header()
-                            .Text("Hello PDF!")
-                            .SemiBold()
-                            .FontSize(36)
-                            .FontColor(Colors.Blue.Medium);
-                        
-                        page.Content()
-                            .PaddingVertical(1, Unit.Centimetre)
-                            .Column(x =>
-                            {
-                                x.Spacing(20);
-                                
-                                x.Item().Text(Placeholders.LoremIpsum());
-                                x.Item().Image(Placeholders.Image(200, 100));
-                            });
-                        
-                        page.Footer()
-                            .AlignCenter()
-                            .Text(x =>
-                            {
-                                x.Span("Page ");
-                                x.CurrentPageNumber();
-                            });
-                    });
-                });
-        }
     }
 }

QuestPDF.Examples/PageBackgroundForegroundExample.cs

@@ -8,15 +8,15 @@ using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Examples
 {
-    public class PageBackgroundForeground
+    public class PageBackgroundForegroundExample
     {
         [Test]
-        public void Test()
+        public void PageBackgroundForeground()
         {
             RenderingTest
                 .Create()
-                .PageSize(550, 400)
-                .ProducePdf()
+                .ProduceImages()
+                .MaxPages(100)
                 .ShowResults()
                 .RenderDocument(document =>
                 {
@@ -25,15 +25,23 @@ namespace QuestPDF.Examples
                         page.Size(PageSizes.A4);
                         page.Margin(1, Unit.Inch);
                         page.DefaultTextStyle(TextStyle.Default.FontSize(16));
+                        page.PageColor(Colors.White);
 
-                        page.Foreground()
-                            .AlignMiddle()
-                            .AlignCenter()
-                            .Text("Watermark")
-                            .FontSize(64)
-                            .FontColor(Colors.Blue.Lighten3);
+                        const string transparentBlue = "#662196f3";
+
+                        page.Background()
+                            .AlignTop()
+                            .ExtendHorizontal()
+                            .Height(200)
+                            .Background(transparentBlue);
                         
-                        page.Header().Text("Background and foreground").Bold().FontColor(Colors.Blue.Medium).FontSize(24);
+                        page.Foreground()
+                            .AlignBottom()
+                            .ExtendHorizontal()
+                            .Height(250)
+                            .Background(transparentBlue);
+                        
+                        page.Header().Text("Background and foreground").Bold().FontColor(Colors.Blue.Darken2).FontSize(36);
                         
                         page.Content().PaddingVertical(25).Column(column =>
                         {

QuestPDF.Examples/ShowOnceExample.cs

@@ -21,7 +21,7 @@ namespace QuestPDF.Examples
                     {
                         page.Margin(20);
                         page.Size(PageSizes.A7.Landscape());
-                        page.Background(Colors.White);
+                        page.PageColor(Colors.White);
 
                         page.Header().Text("With show once").SemiBold();
                         

QuestPDF.Examples/SkipOnceExample.cs

@@ -21,7 +21,7 @@ namespace QuestPDF.Examples
                     {
                         page.Margin(20);
                         page.Size(PageSizes.A7.Landscape());
-                        page.Background(Colors.White);
+                        page.PageColor(Colors.White);
         
                         page.Header().Column(column =>
                         {

QuestPDF.Examples/TextBenchmark.cs

@@ -23,7 +23,7 @@ namespace QuestPDF.Examples
                 .PageSize(PageSizes.A4)
                 .ProducePdf()
                 .ShowResults()
-                .Render(x => ComposeBook(x, chapters));
+                .RenderDocument(x => ComposeBook(x, chapters));
         }
         
         [Test]
@@ -42,8 +42,8 @@ namespace QuestPDF.Examples
                 RenderingTest
                     .Create()
                     .PageSize(PageSizes.A4)
-                        .ProducePdf()
-                    .Render(x => ComposeBook(x, chapters));
+                    .ProducePdf()
+                    .RenderDocument(x => ComposeBook(x, chapters));
             }
 
             IEnumerable<float> PerformTest(int attempts)
@@ -102,37 +102,30 @@ namespace QuestPDF.Examples
             }
         }
         
-        private void ComposeBook(IContainer container, ICollection<BookChapter> chapters)
+        private void ComposeBook(IDocumentContainer container, ICollection<BookChapter> chapters)
         {
             var subtitleStyle = TextStyle.Default.Size(24).SemiBold().Color(Colors.Blue.Medium);
             var normalStyle = TextStyle.Default.Size(14);
-            
-            ComposePage(container);
 
-            void ComposePage(IContainer container)
+            container.Page(page =>
             {
-                container
-                    .Padding(50)
-                    .Decoration(decoration =>
-                    {
-                        decoration
-                            .Content()
-                            .Column(column =>
-                            {
-                                column.Item().Element(Title);
-                                column.Item().PageBreak();
-                                column.Item().Element(TableOfContents);
-                                column.Item().PageBreak();
+                page.Margin(50);
+                
+                page.Content().Column(column =>
+                {
+                    column.Item().Element(Title);
+                    column.Item().PageBreak();
+                    column.Item().Element(TableOfContents);
+                    column.Item().PageBreak();
 
-                                Chapters(column);
+                    Chapters(column);
 
-                                column.Item().Element(Acknowledgements);
-                            });
+                    column.Item().Element(Acknowledgements);
+                });
+                
+                page.Footer().Element(Footer);
+            });
 
-                        decoration.After().Element(Footer);
-                    });
-            }
-            
             void Title(IContainer container)
             {
                 container

QuestPDF.Examples/TextExamples.cs

@@ -29,9 +29,10 @@ namespace QuestPDF.Examples
                         .Padding(10)
                         .Text(text =>
                         {
-                            text.DefaultTextStyle(TextStyle.Default.Size(20));
+                            text.DefaultTextStyle(TextStyle.Default.FontSize(20));
                             text.Span("This is a normal text, followed by an ");
-                            text.Span("underlined red text.").FontSize(20).FontColor(Colors.Red.Medium).Underline();
+                            text.Span("underlined red text").FontColor(Colors.Red.Medium).Underline();
+                            text.Span(".");
                         });
                 });
         }
@@ -81,7 +82,7 @@ namespace QuestPDF.Examples
                         .Padding(10)
                         .Text(text =>
                         {
-                            text.DefaultTextStyle(TextStyle.Default.Size(20));
+                            text.DefaultTextStyle(TextStyle.Default.FontSize(20));
                             text.Span("This is a random image aligned to the baseline: ");
                             
                             text.Element()
@@ -191,7 +192,7 @@ namespace QuestPDF.Examples
                             text.EmptyLine();
 
                             text.Span("The new text element also supports injecting custom content between words: ");
-                            text.Element().PaddingBottom(-10).Height(16).Width(32).Image(Placeholders.Image);
+                            text.Element().PaddingBottom(-4).Height(16).Width(32).Image(Placeholders.Image);
                             text.Span(".");
 
                             text.EmptyLine();
@@ -203,7 +204,7 @@ namespace QuestPDF.Examples
 
                             text.EmptyLine();
 
-                            text.ExternalLocation("Please visit QuestPDF website", "https://www.questpdf.com");
+                            text.Hyperlink("Please visit QuestPDF website", "https://www.questpdf.com");
 
                             text.EmptyLine();
 
@@ -238,7 +239,7 @@ namespace QuestPDF.Examples
                         .Padding(10)
                         .Text(text =>
                         {
-                            text.DefaultTextStyle(TextStyle.Default);
+                            text.DefaultTextStyle(TextStyle.Default.FontSize(20));
                             text.AlignLeft();
                             text.ParagraphSpacing(10);
 
@@ -248,7 +249,7 @@ namespace QuestPDF.Examples
                             text.Span("and this is slightly bigger text.").FontSize(16);
                             
                             text.Span("The new text element also supports injecting custom content between words: ");
-                            text.Element().PaddingBottom(-10).Height(16).Width(32).Image(Placeholders.Image);
+                            text.Element().PaddingBottom(-4).Height(16).Width(32).Image(Placeholders.Image);
                             text.Span(".");
                             
                             text.EmptyLine();
@@ -257,7 +258,7 @@ namespace QuestPDF.Examples
                             {
                                 text.Line($"{i}: {Placeholders.Paragraph()}");
 
-                                text.ExternalLocation("Please visit QuestPDF website", "https://www.questpdf.com");
+                                text.Hyperlink("Please visit QuestPDF website", "https://www.questpdf.com");
                                 
                                 text.Span("This is page number ");
                                 text.CurrentPageNumber();
@@ -269,5 +270,106 @@ namespace QuestPDF.Examples
                         });
                 });
         }
+        
+        [Test]
+        public void MeasureIssueWhenSpaceAtLineEnd()
+        {
+            // issue 135
+            
+            RenderingTest
+                .Create()
+                .ProduceImages()
+                .ShowResults()
+                .RenderDocument(container =>
+                {
+                    container.Page(page =>
+                    {
+                        page.Margin(50);
+                        page.PageColor(Colors.White);
+
+                        page.Size(PageSizes.A4);
+
+                        page.Content().Text("This is a specially crafted sentence with a specially chosen length for demonstration of the bug that occurs ;;;;;. ").FontSize(11).BackgroundColor(Colors.Red.Lighten3);
+                    });
+                });
+        }
+        
+        [Test]
+        public void EmptyText()
+        {
+            // issue 135
+            
+            RenderingTest
+                .Create()
+                .ProduceImages()
+                .ShowResults()
+                .RenderDocument(container =>
+                {
+                    container.Page(page =>
+                    {
+                        page.Margin(50);
+                        page.PageColor(Colors.White);
+
+                        page.Size(PageSizes.A4);
+
+                        page.Content().Text("         ").FontSize(11).BackgroundColor(Colors.Red.Lighten3);
+                    });
+                });
+        }
+        
+        [Test]
+        public void Whitespaces()
+        {
+            // issue 135
+            
+            RenderingTest
+                .Create()
+                .ProduceImages()
+                .ShowResults()
+                .RenderDocument(container =>
+                {
+                    container.Page(page =>
+                    {
+                        page.Margin(50);
+                        page.PageColor(Colors.White);
+
+                        page.Size(PageSizes.A4);
+
+                        page.Content().Text("     x     ").FontSize(11).BackgroundColor(Colors.Red.Lighten3);
+                    });
+                });
+        }
+        
+        [Test]
+        public void DrawingNullTextShouldNotThrowException()
+        {
+            RenderingTest
+                .Create()
+                .ProduceImages()
+                .ShowResults()
+                .RenderDocument(container =>
+                {
+                    container.Page(page =>
+                    {
+                        page.Margin(50);
+                        page.PageColor(Colors.White);
+
+                        page.Size(PageSizes.A4);
+
+                        page.Content().Column(column =>
+                        {
+                            column.Item().Text(null);
+
+                            column.Item().Text(text =>
+                            {
+                                text.Span(null);
+                                text.Line(null);
+                                text.Hyperlink(null, "http://www.questpdf.com");
+                                text.TotalPages().Format(x => null);
+                            });
+                        });
+                    });
+                });
+        }
     }
 }

QuestPDF.Previewer.Examples/Program.cs

@@ -0,0 +1,80 @@
+using Avalonia.Media;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+using QuestPDF.Previewer;
+using QuestPDF.ReportSample;
+using QuestPDF.ReportSample.Layouts;
+using Colors = QuestPDF.Helpers.Colors;
+
+var model = DataSource.GetReport();
+var report = new StandardReport(model);
+report.ShowInPreviewer();
+
+return;
+
+Document
+    .Create(container =>
+    {
+        container.Page(page =>
+        {
+            page.Size(PageSizes.A4);
+            page.Margin(2, Unit.Centimetre);
+            page.PageColor(Colors.White);
+            page.DefaultTextStyle(x => x.FontSize(20));
+
+            page.Header()
+                .Text("Hot Reload!")
+                .SemiBold().FontSize(36).FontColor(Colors.Blue.Darken2);
+
+            page.Content()
+                .PaddingVertical(1, Unit.Centimetre)
+                .Column(x =>
+                {
+                    x.Spacing(20);
+
+                    x.Item().Table(t =>
+                    {
+                        t.ColumnsDefinition(c =>
+                        {
+                            c.RelativeColumn();
+                            c.RelativeColumn(3);
+                        });
+
+                        t.Cell().Border(1).Background(Colors.Grey.Lighten3).Padding(5).Text("Visual Studio");
+                        t.Cell().Border(1).Padding(5).Text("Start in debug mode with 'Hot Reload on Save' enabled.");
+                        t.Cell().Border(1).Background(Colors.Grey.Lighten3).Padding(5).Text("Command line");
+                        t.Cell().Border(1).Padding(5).Text("Run 'dotnet watch'.");
+                    });
+
+                    x.Item().Text("Modify this line and the preview should show your changes instantly.");
+                });
+
+            page.Footer()
+                .AlignCenter()
+                .Text(x =>
+                {
+                    x.Span("Page ");
+                    x.CurrentPageNumber();
+                });
+        });
+        
+        container.Page(page =>
+        {
+            page.Size(PageSizes.A4);
+            page.Margin(2, Unit.Centimetre);
+            page.PageColor(Colors.Red.Medium);
+            page.DefaultTextStyle(x => x.FontSize(20));
+
+            page.Content()
+                .PaddingVertical(1, Unit.Centimetre)
+                .Column(x =>
+                {
+                    x.Spacing(20);
+
+                    foreach (var i in Enumerable.Range(0, 10))
+                        x.Item().Background(Colors.Grey.Lighten2).Height(80);
+                });
+        });
+    })
+    .ShowInPreviewer();

QuestPDF.Previewer.Examples/QuestPDF.Previewer.Examples.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\QuestPDF.Previewer\QuestPDF.Previewer.csproj" />
+    <ProjectReference Include="..\QuestPDF.ReportSample\QuestPDF.ReportSample.csproj" />
+    <ProjectReference Include="..\QuestPDF\QuestPDF.csproj" />
+  </ItemGroup>
+
+</Project>

QuestPDF.Previewer/DocumentPreviewerExtensions.cs

@@ -0,0 +1,50 @@
+using Avalonia;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.ReactiveUI;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Previewer
+{
+    public static class DocumentPreviewerExtensions
+    {
+        /// <summary>
+        /// Opens document in the QuestPDF previewer tool.
+        /// Improves development speed by supporting hot reloading.
+        /// Shows document preview and refreshes it after each code change.
+        /// </summary>
+        /// <remarks>
+        /// Intended for development only. Do not use in production environment.
+        /// </remarks>
+        public static void ShowInPreviewer(this IDocument document)
+        {
+            ArgumentNullException.ThrowIfNull(document);
+
+            // currently there is no way to utilize a previously run Avalonia app.
+            // so we need to check if the previewer was already run and show the window again.
+            if(Application.Current?.ApplicationLifetime is ClassicDesktopStyleApplicationLifetime desktop)
+            {
+                desktop.MainWindow = new PreviewerWindow()
+                {
+                    DataContext = new PreviewerWindowViewModel()
+                    {
+                        Document = document,
+                    }
+                };
+                
+                desktop.MainWindow.Show();
+                desktop.Start(Array.Empty<string>());
+                
+                return;
+            }
+
+            AppBuilder
+                .Configure(() => new PreviewerApp()
+                {
+                    Document = document,
+                })
+                .UsePlatformDetect()
+                .UseReactiveUI()
+                .StartWithClassicDesktopLifetime(Array.Empty<string>());
+        }
+    }
+}

QuestPDF.Previewer/DocumentRenderer.cs

@@ -0,0 +1,63 @@
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using Avalonia.Threading;
+using QuestPDF.Drawing;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Previewer
+{
+    internal class DocumentRenderer : INotifyPropertyChanged
+    {
+        public IDocument? Document { get; private set; }
+
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        private ObservableCollection<PreviewPage> _pages = new();
+        public ObservableCollection<PreviewPage> Pages
+        {
+            get => _pages;
+            set
+            {
+                if (_pages != value)
+                {
+                    _pages = value;
+                    PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(Pages)));
+                }
+            }
+        }
+
+        public void UpdateDocument(IDocument? document)
+        {
+            Document = document;
+            
+            if (document == null) 
+                return;
+            
+            try
+            {
+                RenderDocument(document);
+            }
+            catch (Exception exception)
+            {
+                var exceptionDocument = new ExceptionDocument(exception);
+                RenderDocument(exceptionDocument);
+            }
+        }
+
+        private void RenderDocument(IDocument document)
+        {
+            var canvas = new PreviewerCanvas();
+
+            DocumentGenerator.RenderDocument(canvas, document);
+            
+            foreach (var pages in Pages)
+                pages?.Picture?.Dispose();
+            
+            Dispatcher.UIThread.Post(() =>
+            {
+                Pages.Clear();
+                Pages = new ObservableCollection<PreviewPage>(canvas.Pictures);
+            });
+        }
+    }
+}

QuestPDF.Previewer/ExceptionDocument.cs

@@ -0,0 +1,55 @@
+using QuestPDF.Drawing;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Previewer;
+
+public class ExceptionDocument : IDocument
+{
+    private Exception Exception { get; }
+    
+    public ExceptionDocument(Exception exception)
+    {
+        Exception = exception;
+    }
+    
+    public DocumentMetadata GetMetadata()
+    {
+        return DocumentMetadata.Default;
+    }
+
+    public void Compose(IDocumentContainer document)
+    {
+        document.Page(page =>
+        {
+            page.Size(PageSizes.A4);
+            page.Margin(1, Unit.Inch);
+            page.PageColor(Colors.Red.Lighten4);
+            page.DefaultTextStyle(x => x.FontSize(16));
+
+            page.Header()
+                .BorderBottom(2)
+                .BorderColor(Colors.Red.Medium)
+                .PaddingBottom(5)
+                .Text("Ooops! Something went wrong...").FontSize(28).FontColor(Colors.Red.Medium).Bold();
+
+            page.Content().PaddingVertical(20).Column(column =>
+            {
+                var currentException = Exception;
+
+                while (currentException != null)
+                {
+                    column.Item().Text(currentException.GetType().Name).FontSize(20).SemiBold();
+                    column.Item().Text(currentException.Message).FontSize(14);
+                    column.Item().PaddingTop(10).Text(currentException.StackTrace).FontSize(10).Light();
+
+                    currentException = currentException.InnerException;
+
+                    if (currentException != null)
+                        column.Item().PaddingVertical(15).LineHorizontal(2).LineColor(Colors.Red.Medium);
+                }
+            });
+        });
+    }
+}

QuestPDF.Previewer/HotReloadManager.cs

@@ -0,0 +1,17 @@
+[assembly: System.Reflection.Metadata.MetadataUpdateHandler(typeof(QuestPDF.Previewer.HotReloadManager))]
+
+namespace QuestPDF.Previewer
+{
+    /// <summary>
+    /// Helper for subscribing to hot reload notifications.
+    /// </summary>
+    internal static class HotReloadManager
+    {
+        public static event EventHandler? UpdateApplicationRequested;
+
+        public static void UpdateApplication(Type[]? _)
+        {
+            UpdateApplicationRequested?.Invoke(null, EventArgs.Empty);
+        }
+    }
+}

QuestPDF.Previewer/InteractiveCanvas.cs

@@ -0,0 +1,205 @@
+using System.Diagnostics;
+using Avalonia;
+using Avalonia.Platform;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Skia;
+using SkiaSharp;
+
+namespace QuestPDF.Previewer;
+
+class InteractiveCanvas : ICustomDrawOperation
+{
+    public Rect Bounds { get; set; }
+    public ICollection<PreviewPage> Pages { get; set; }
+
+    private float Width => (float)Bounds.Width;
+    private float Height => (float)Bounds.Height;
+
+    public float Scale { get; private set; } = 1;
+    public float TranslateX { get; set; }
+    public float TranslateY { get; set; }
+
+    private const float MinScale = 0.1f;
+    private const float MaxScale = 10f;
+
+    private const float PageSpacing = 25f;
+    private const float SafeZone = 25f;
+
+    public float TotalPagesHeight => Pages.Sum(x => x.Size.Height) + (Pages.Count - 1) * PageSpacing;
+    public float TotalHeight => TotalPagesHeight + SafeZone * 2 / Scale;
+    public float MaxWidth => Pages.Any() ? Pages.Max(x => x.Size.Width) : 0;
+    
+    public float MaxTranslateY => TotalHeight - Height / Scale;
+
+    public float ScrollPercentY
+    {
+        get
+        {
+            return TranslateY / MaxTranslateY;
+        }
+        set
+        {
+            TranslateY = value * MaxTranslateY;
+        }
+    }
+
+    public float ScrollViewportSizeY
+    {
+        get
+        {
+            var viewPortSize = Height / Scale / TotalHeight;
+            return Math.Clamp(viewPortSize, 0, 1);
+        }
+    }
+
+    #region transformations
+    
+    private void LimitScale()
+    {
+        Scale = Math.Max(Scale, MinScale);
+        Scale = Math.Min(Scale, MaxScale);
+    }
+    
+    private void LimitTranslate()
+    {
+        if (TotalPagesHeight > Height / Scale)
+        {
+            TranslateY = Math.Min(TranslateY, MaxTranslateY);
+            TranslateY = Math.Max(TranslateY, 0);
+        }
+        else
+        {
+            TranslateY = (TotalPagesHeight - Height / Scale) / 2;
+        }
+
+        if (Width / Scale < MaxWidth)
+        {
+            var maxTranslateX = (Width / 2 - SafeZone) / Scale - MaxWidth / 2;
+
+            TranslateX = Math.Min(TranslateX, -maxTranslateX);
+            TranslateX = Math.Max(TranslateX, maxTranslateX);
+        }
+        else
+        {
+            TranslateX = 0;
+        }
+    }
+
+    public void TranslateWithCurrentScale(float x, float y)
+    {
+        TranslateX += x / Scale;
+        TranslateY += y / Scale;
+
+        LimitTranslate();
+    }
+    
+    public void ZoomToPoint(float x, float y, float factor)
+    {
+        var oldScale = Scale;
+        Scale *= factor;
+                
+        LimitScale();
+                
+        factor = Scale / oldScale;
+        
+        TranslateX -= x / (oldScale * factor) - x / oldScale;
+        TranslateY -= y / (oldScale * factor) - y / oldScale;
+
+        LimitTranslate();
+    }
+    
+    #endregion
+    
+    #region rendering
+    
+    public void Render(IDrawingContextImpl context)
+    {
+        if (Pages.Count <= 0)
+            return;
+
+        LimitScale();
+        LimitTranslate();
+        
+        var canvas = (context as ISkiaDrawingContextImpl)?.SkCanvas;
+        
+        if (canvas == null)
+            throw new InvalidOperationException($"Context needs to be ISkiaDrawingContextImpl but got {nameof(context)}");
+
+        var originalMatrix = canvas.TotalMatrix;
+
+        canvas.Translate(Width / 2, 0);
+        
+        canvas.Scale(Scale);
+        canvas.Translate(TranslateX, -TranslateY + SafeZone / Scale);
+        
+        foreach (var page in Pages)
+        {
+            canvas.Translate(-page.Size.Width / 2f, 0);
+            DrawBlankPage(canvas, page.Size);
+            canvas.DrawPicture(page.Picture);
+            canvas.Translate(page.Size.Width / 2f, page.Size.Height + PageSpacing);
+        }
+
+        canvas.SetMatrix(originalMatrix);
+        DrawInnerGradient(canvas);
+    }
+    
+    public void Dispose() { }
+    public bool Equals(ICustomDrawOperation? other) => false;
+    public bool HitTest(Point p) => true;
+
+    #endregion
+    
+    #region blank page
+
+    private static SKPaint BlankPagePaint = new SKPaint
+    {
+        Color = SKColors.White
+    };
+    
+    private static SKPaint BlankPageShadowPaint = new SKPaint
+    {
+        ImageFilter = SKImageFilter.CreateBlendMode(
+            SKBlendMode.Overlay, 
+            SKImageFilter.CreateDropShadowOnly(0, 6, 6, 6, SKColors.Black.WithAlpha(64)),
+            SKImageFilter.CreateDropShadowOnly(0, 10, 14, 14, SKColors.Black.WithAlpha(32)))
+    };
+    
+    private void DrawBlankPage(SKCanvas canvas, QuestPDF.Infrastructure.Size size)
+    {
+        canvas.DrawRect(0, 0, size.Width, size.Height, BlankPageShadowPaint);
+        canvas.DrawRect(0, 0, size.Width, size.Height, BlankPagePaint);
+    }
+    
+    #endregion
+
+    #region inner viewport gradient
+
+    private const int InnerGradientSize = (int)SafeZone;
+    private static readonly SKColor InnerGradientColor = SKColor.Parse("#666");
+    
+    private void DrawInnerGradient(SKCanvas canvas)
+    {
+        // gamma correction
+        var colors = Enumerable
+            .Range(0, InnerGradientSize)
+            .Select(x => 1f - x / (float) InnerGradientSize)
+            .Select(x => Math.Pow(x, 2f))
+            .Select(x => (byte)(x * 255))
+            .Select(x => InnerGradientColor.WithAlpha(x))
+            .ToArray();
+        
+        using var fogPaint = new SKPaint
+        {
+            Shader = SKShader.CreateLinearGradient(
+                new SKPoint(0, 0),
+                new SKPoint(0, InnerGradientSize), 
+                colors,
+                SKShaderTileMode.Clamp)
+        };
+        
+        canvas.DrawRect(0, 0, Width, InnerGradientSize, fogPaint);
+    }
+
+    #endregion
+}

QuestPDF.Previewer/PreviewerApp.axaml

@@ -0,0 +1,7 @@
+<Application x:Class="QuestPDF.Previewer.PreviewerApp"
+             xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+	<Application.Styles>
+		<FluentTheme Mode="Dark" />
+	</Application.Styles>
+</Application>

QuestPDF.Previewer/PreviewerApp.axaml.cs

@@ -0,0 +1,33 @@
+using Avalonia;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Markup.Xaml;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Previewer
+{
+    internal class PreviewerApp : Application
+    {
+        public IDocument? Document { get; init; }
+
+        public override void Initialize()
+        {
+            AvaloniaXamlLoader.Load(this);
+        }
+
+        public override void OnFrameworkInitializationCompleted()
+        {
+            if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
+            {
+                desktop.MainWindow = new PreviewerWindow()
+                {
+                    DataContext = new PreviewerWindowViewModel()
+                    {
+                        Document = Document,
+                    }
+                };
+            }
+            
+            base.OnFrameworkInitializationCompleted();
+        }
+    }
+}

QuestPDF.Previewer/PreviewerCanvas.cs

@@ -0,0 +1,42 @@
+using QuestPDF.Drawing;
+using QuestPDF.Infrastructure;
+using SkiaSharp;
+
+namespace QuestPDF.Previewer
+{
+    record PreviewPage(SKPicture Picture, Size Size);
+    
+    sealed class PreviewerCanvas : SkiaCanvasBase, IRenderingCanvas
+    {
+        private SKPictureRecorder? PictureRecorder { get; set; }
+        private Size? CurrentPageSize { get; set; }
+        
+        public ICollection<PreviewPage> Pictures { get; } = new List<PreviewPage>();
+        
+        public override void BeginDocument()
+        {
+            Pictures.Clear();
+        }
+
+        public override void BeginPage(Size size)
+        {
+            CurrentPageSize = size;
+            PictureRecorder = new SKPictureRecorder();
+            
+            Canvas = PictureRecorder.BeginRecording(new SKRect(0, 0, size.Width, size.Height));
+        }
+
+        public override void EndPage()
+        {
+            var picture = PictureRecorder?.EndRecording();
+            
+            if (picture != null && CurrentPageSize.HasValue)
+                Pictures.Add(new PreviewPage(picture, CurrentPageSize.Value));
+
+            PictureRecorder?.Dispose();
+            PictureRecorder = null;
+        }
+
+        public override void EndDocument() { }
+    }
+}

QuestPDF.Previewer/PreviewerControl.cs

@@ -0,0 +1,120 @@
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Media;
+using ReactiveUI;
+
+namespace QuestPDF.Previewer
+{
+    class PreviewerControl : Control
+    {
+        private InteractiveCanvas InteractiveCanvas { get; set; } = new ();
+        
+        public static readonly StyledProperty<ObservableCollection<PreviewPage>> PagesProperty =
+            AvaloniaProperty.Register<PreviewerControl, ObservableCollection<PreviewPage>>(nameof(Pages));
+        
+        public ObservableCollection<PreviewPage>? Pages
+        {
+            get => GetValue(PagesProperty);
+            set => SetValue(PagesProperty, value);
+        }
+
+        public static readonly StyledProperty<float> CurrentScrollProperty = AvaloniaProperty.Register<PreviewerControl, float>(nameof(CurrentScroll));
+        
+        public float CurrentScroll
+        {
+            get => GetValue(CurrentScrollProperty);
+            set => SetValue(CurrentScrollProperty, value);
+        }
+        
+        public static readonly StyledProperty<float> ScrollViewportSizeProperty = AvaloniaProperty.Register<PreviewerControl, float>(nameof(ScrollViewportSize));
+        
+        public float ScrollViewportSize
+        {
+            get => GetValue(ScrollViewportSizeProperty);
+            set => SetValue(ScrollViewportSizeProperty, value);
+        }
+        
+        public PreviewerControl()
+        {
+            PagesProperty.Changed.Subscribe(x =>
+            {
+                InteractiveCanvas.Pages = x.NewValue.Value;
+                InvalidateVisual();
+            });
+
+            CurrentScrollProperty.Changed.Subscribe(x =>
+            {
+                InteractiveCanvas.ScrollPercentY = x.NewValue.Value;
+                InvalidateVisual();
+            });
+
+            ClipToBounds = true;
+        }
+        
+        protected override void OnPointerWheelChanged(PointerWheelEventArgs e)
+        {
+            base.OnPointerWheelChanged(e);
+
+            if ((e.KeyModifiers & KeyModifiers.Control) != 0)
+            {
+                var scaleFactor = 1 + e.Delta.Y / 10f;
+                var point = new Point(Bounds.Center.X, Bounds.Top) - e.GetPosition(this);
+                
+                InteractiveCanvas.ZoomToPoint((float)point.X, -(float)point.Y, (float)scaleFactor);
+            }
+                
+            if (e.KeyModifiers == KeyModifiers.None)
+            {
+                var translation = (float)e.Delta.Y * 25;
+                InteractiveCanvas.TranslateWithCurrentScale(0, -translation);
+            }
+                
+            InvalidateVisual();
+        }
+
+        private bool IsMousePressed { get; set; }
+        private Vector MousePosition { get; set; }
+        
+        protected override void OnPointerMoved(PointerEventArgs e)
+        {
+            base.OnPointerMoved(e);
+
+            if (IsMousePressed)
+            {
+                var currentPosition = e.GetPosition(this);
+                var translation = currentPosition - MousePosition;
+                InteractiveCanvas.TranslateWithCurrentScale((float)translation.X, -(float)translation.Y);
+                
+                InvalidateVisual();
+            }
+
+            MousePosition = e.GetPosition(this);
+        }
+        
+        protected override void OnPointerPressed(PointerPressedEventArgs e)
+        {
+            base.OnPointerPressed(e);
+            IsMousePressed = true;
+        }
+
+        protected override void OnPointerReleased(PointerReleasedEventArgs e)
+        {
+            base.OnPointerReleased(e);
+            IsMousePressed = false;
+        }
+
+        public override void Render(DrawingContext context)
+        {
+            CurrentScroll = InteractiveCanvas.ScrollPercentY;
+            ScrollViewportSize = InteractiveCanvas.ScrollViewportSizeY;
+    
+            InteractiveCanvas.Bounds = new Rect(0, 0, Bounds.Width, Bounds.Height);
+
+            context.Custom(InteractiveCanvas);
+            base.Render(context);
+        }
+    }
+}

QuestPDF.Previewer/PreviewerWindow.axaml

@@ -0,0 +1,82 @@
+<Window xmlns="https://github.com/avaloniaui"
+							xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+							xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+							xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+							xmlns:previewer="clr-namespace:QuestPDF.Previewer"
+							mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
+							x:Class="QuestPDF.Previewer.PreviewerWindow"
+							WindowStartupLocation="CenterScreen"
+							ExtendClientAreaToDecorationsHint="true"
+							ExtendClientAreaTitleBarHeightHint="-1"
+							Background="#666"
+							Icon="/Images/Logo.png"
+							UseLayoutRounding="True"
+							Title="QuestPDF Document Preview">
+	<Panel>
+		<Grid>
+			<Grid.RowDefinitions>
+				<RowDefinition Height="32" />
+				<RowDefinition Height="*" />
+			</Grid.RowDefinitions>
+
+			<Grid.ColumnDefinitions>
+				<ColumnDefinition Width="*" />
+				<ColumnDefinition Width="Auto" />
+			</Grid.ColumnDefinitions>
+			
+			<TextBlock Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="2"
+			           VerticalAlignment="Center" HorizontalAlignment="Center" 
+			           TextAlignment="Center" Text="QuestPDF Previewer" FontSize="14" Foreground="#DFFF" FontWeight="Regular" IsHitTestVisible="False" />
+			
+			<previewer:PreviewerControl Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="2"
+			                            HorizontalAlignment="Stretch" 
+			                            VerticalAlignment="Stretch"
+			                            CurrentScroll="{Binding CurrentScroll, Mode=TwoWay}"
+			                            ScrollViewportSize="{Binding ScrollViewportSize, Mode=OneWayToSource}"
+			                            Pages="{Binding DocumentRenderer.Pages, Mode=OneWay}" />
+			
+			<StackPanel Grid.Row="1" Grid.Column="0" Orientation="Vertical" VerticalAlignment="Bottom" Spacing="16" Margin="32" ZIndex="100">
+				<Button VerticalAlignment="Bottom" HorizontalAlignment="Left" 
+				        Padding="10" CornerRadius="100" 
+				        Command="{Binding ShowPdfCommand, Mode=OneTime}"
+				        ToolTip.Tip="Generates PDF file and shows it in the default browser. Useful for testing compatibility and interactive links.">
+					<Viewbox Width="24" Height="24">
+						<Canvas Width="24" Height="24">
+							<Path Fill="White" Data="M14,2H6A2,2 0 0,0 4,4V20A2,2 0 0,0 6,22H13C12.59,21.75 12.2,21.44 11.86,21.1C11.53,20.77 11.25,20.4 11,20H6V4H13V9H18V10.18C18.71,10.34 19.39,10.61 20,11V8L14,2M20.31,18.9C21.64,16.79 21,14 18.91,12.68C16.8,11.35 14,12 12.69,14.08C11.35,16.19 12,18.97 14.09,20.3C15.55,21.23 17.41,21.23 18.88,20.32L22,23.39L23.39,22L20.31,18.9M16.5,19A2.5,2.5 0 0,1 14,16.5A2.5,2.5 0 0,1 16.5,14A2.5,2.5 0 0,1 19,16.5A2.5,2.5 0 0,1 16.5,19Z" />
+						</Canvas>
+					</Viewbox>
+				</Button>
+				
+				<Button VerticalAlignment="Bottom" HorizontalAlignment="Left" 
+				        Padding="10" CornerRadius="100" 
+				        Command="{Binding ShowDocumentationCommand, Mode=OneTime}"
+				        ToolTip.Tip="Opens official QuestPDF documentation">
+					<Viewbox Width="24" Height="24">
+						<Canvas Width="24" Height="24">
+							<Path Fill="White" Data="M19 1L14 6V17L19 12.5V1M21 5V18.5C19.9 18.15 18.7 18 17.5 18C15.8 18 13.35 18.65 12 19.5V6C10.55 4.9 8.45 4.5 6.5 4.5C4.55 4.5 2.45 4.9 1 6V20.65C1 20.9 1.25 21.15 1.5 21.15C1.6 21.15 1.65 21.1 1.75 21.1C3.1 20.45 5.05 20 6.5 20C8.45 20 10.55 20.4 12 21.5C13.35 20.65 15.8 20 17.5 20C19.15 20 20.85 20.3 22.25 21.05C22.35 21.1 22.4 21.1 22.5 21.1C22.75 21.1 23 20.85 23 20.6V6C22.4 5.55 21.75 5.25 21 5M10 18.41C8.75 18.09 7.5 18 6.5 18C5.44 18 4.18 18.19 3 18.5V7.13C3.91 6.73 5.14 6.5 6.5 6.5C7.86 6.5 9.09 6.73 10 7.13V18.41Z" />
+						</Canvas>
+					</Viewbox>
+				</Button>
+				
+				<Button VerticalAlignment="Bottom" HorizontalAlignment="Left" 
+				        Padding="10" CornerRadius="100" 
+				        Command="{Binding SponsorProjectCommand, Mode=OneTime}"
+				        ToolTip.Tip="Do you like QuestPDF? Please consider sponsoring the project. It really helps!">
+					<Viewbox Width="24" Height="24">
+						<Canvas Width="24" Height="24">
+							<Path Fill="White" Data="M12,21.1L10.5,22.4C3.9,16.5 0.5,13.4 0.5,9.6C0.5,8.4 0.9,7.3 1.5,6.4C1.5,6.6 1.5,6.8 1.5,7C1.5,11.7 5.4,15.2 12,21.1M13.6,17C18.3,12.7 21.5,9.9 21.6,7C21.6,5 20.1,3.5 18.1,3.5C16.5,3.5 15,4.5 14.5,5.9H12.6C12,4.5 10.5,3.5 9,3.5C7,3.5 5.5,5 5.5,7C5.5,9.9 8.6,12.7 13.4,17L13.5,17.1M18,1.5C21.1,1.5 23.5,3.9 23.5,7C23.5,10.7 20.1,13.8 13.5,19.8C6.9,13.9 3.5,10.8 3.5,7C3.5,3.9 5.9,1.5 9,1.5C10.7,1.5 12.4,2.3 13.5,3.6C14.6,2.3 16.3,1.5 18,1.5Z" />
+						</Canvas>
+					</Viewbox>
+				</Button>
+			</StackPanel>
+			
+			<ScrollBar Grid.Row="1" Grid.Column="1"
+			           Orientation="Vertical" 
+			           AllowAutoHide="False" 
+			           Minimum="0" Maximum="1" 
+			           IsVisible="{Binding VerticalScrollbarVisible, Mode=OneWay}"
+			           Value="{Binding CurrentScroll, Mode=TwoWay}" 
+			           ViewportSize="{Binding ScrollViewportSize, Mode=OneWay}"></ScrollBar>
+		</Grid>
+	</Panel>
+</Window>

QuestPDF.Previewer/PreviewerWindow.axaml.cs

@@ -0,0 +1,23 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace QuestPDF.Previewer
+{
+    class PreviewerWindow : Window
+    {
+        public PreviewerWindow()
+        {
+            InitializeComponent();
+        }
+
+        protected override void OnClosed(EventArgs e)
+        {
+            (DataContext as PreviewerWindowViewModel)?.UnregisterHotReloadHandler();
+        }
+
+        private void InitializeComponent()
+        {
+            AvaloniaXamlLoader.Load(this);
+        }
+    }
+}

QuestPDF.Previewer/PreviewerWindowViewModel.cs

@@ -0,0 +1,108 @@
+using QuestPDF.Fluent;
+using System.Diagnostics;
+using ReactiveUI;
+using QuestPDF.Infrastructure;
+using Unit = System.Reactive.Unit;
+using Avalonia.Threading;
+
+namespace QuestPDF.Previewer
+{
+    internal class PreviewerWindowViewModel : ReactiveObject
+    {
+        public DocumentRenderer DocumentRenderer { get; } = new();
+
+        private IDocument? _document;
+        public IDocument? Document
+        {
+            get => _document;
+            set
+            {
+                this.RaiseAndSetIfChanged(ref _document, value);
+                UpdateDocument(value);
+            }
+        }
+
+        private float _currentScroll;
+        public float CurrentScroll
+        {
+            get => _currentScroll;
+            set => this.RaiseAndSetIfChanged(ref _currentScroll, value);
+        }
+
+        private float _scrollViewportSize;
+        public float ScrollViewportSize
+        {
+            get => _scrollViewportSize;
+            set
+            {
+                this.RaiseAndSetIfChanged(ref _scrollViewportSize, value);
+                VerticalScrollbarVisible = value < 1;
+            }
+        }
+
+        private bool _verticalScrollbarVisible;
+        public bool VerticalScrollbarVisible
+        {
+            get => _verticalScrollbarVisible;
+            private set => Dispatcher.UIThread.Post(() => this.RaiseAndSetIfChanged(ref _verticalScrollbarVisible, value));
+        }
+
+        public ReactiveCommand<Unit, Unit> ShowPdfCommand { get; }
+        public ReactiveCommand<Unit, Unit> ShowDocumentationCommand { get; }
+        public ReactiveCommand<Unit, Unit> SponsorProjectCommand { get; }
+
+        public PreviewerWindowViewModel()
+        {
+            HotReloadManager.UpdateApplicationRequested += InvalidateDocument;
+            
+            ShowPdfCommand = ReactiveCommand.Create(ShowPdf);
+            ShowDocumentationCommand = ReactiveCommand.Create(() => OpenLink("https://www.questpdf.com/documentation/api-reference.html"));
+            SponsorProjectCommand = ReactiveCommand.Create(() => OpenLink("https://github.com/sponsors/QuestPDF"));
+        }
+
+        public void UnregisterHotReloadHandler()
+        {
+            HotReloadManager.UpdateApplicationRequested -= InvalidateDocument;
+        }
+
+        private void InvalidateDocument(object? sender, EventArgs e)
+        {
+            UpdateDocument(Document);
+        }
+
+        private Task UpdateDocument(IDocument? document)
+        {
+            return Task.Run(() => DocumentRenderer.UpdateDocument(document));
+        }
+
+        private void ShowPdf()
+        {
+            var filePath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid():N}.pdf");
+
+            try
+            {
+                Document?.GeneratePdf(filePath);
+            }
+            catch (Exception exception)
+            {
+                new ExceptionDocument(exception).GeneratePdf(filePath);
+            }
+
+            OpenLink(filePath);
+        }
+        
+        private void OpenLink(string path)
+        {
+            var openBrowserProcess = new Process
+            {
+                StartInfo = new()
+                {
+                    UseShellExecute = true,
+                    FileName = path
+                }
+            };
+
+            openBrowserProcess.Start();
+        }
+    }
+}

QuestPDF.Previewer/QuestPDF.Previewer.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <AvaloniaResource Include="Images\Logo.png" />
+  </ItemGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Avalonia" Version="0.10.10" />
+		<PackageReference Include="Avalonia.Desktop" Version="0.10.10" />
+		<PackageReference Include="Avalonia.Diagnostics" Version="0.10.10" />
+		<PackageReference Include="Avalonia.Markup.Xaml.Loader" Version="0.10.10" />
+		<PackageReference Include="Avalonia.ReactiveUI" Version="0.10.10" />
+		<PackageReference Include="ReactiveUI" Version="17.1.50" />
+		<PackageReference Include="System.Reactive" Version="5.0.0" />
+	</ItemGroup>
+
+	<ItemGroup>
+	  <ProjectReference Include="..\QuestPDF\QuestPDF.csproj" />
+	</ItemGroup>
+
+</Project>

QuestPDF.ReportSample/Layouts/PhotoTemplate.cs

@@ -1,3 +1,4 @@
+using System;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
@@ -47,7 +48,7 @@ namespace QuestPDF.ReportSample.Layouts
             container.Border(0.75f).BorderColor(Colors.Grey.Medium).Grid(grid =>
             {
                 grid.Columns(6);
-                
+
                 grid.Item().LabelCell().Text("Date");
                 grid.Item(2).ValueCell().Text(Model.Date?.ToString("g") ?? string.Empty);
                 grid.Item().LabelCell().Text("Location");

QuestPDF.sln

@@ -8,6 +8,15 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "QuestPDF.UnitTests", "Quest
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "QuestPDF.Examples", "QuestPDF.Examples\QuestPDF.Examples.csproj", "{8BD0A2B4-2DC1-47BA-9724-C158320D9CAE}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "QuestPDF.Previewer", "QuestPDF.Previewer\QuestPDF.Previewer.csproj", "{D63255E7-7043-4AD4-A4C9-7ACFEDBE8225}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "QuestPDF.Previewer.Examples", "QuestPDF.Previewer.Examples\QuestPDF.Previewer.Examples.csproj", "{CA413A39-038F-4A9F-B56F-0E5413B6B158}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Configuration", "Configuration", "{73123649-216A-47B4-BFB2-DADF13FBE75D}"
+	ProjectSection(SolutionItems) = preProject
+		.editorconfig = .editorconfig
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -30,5 +39,13 @@ Global
 		{8BD0A2B4-2DC1-47BA-9724-C158320D9CAE}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{8BD0A2B4-2DC1-47BA-9724-C158320D9CAE}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{8BD0A2B4-2DC1-47BA-9724-C158320D9CAE}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D63255E7-7043-4AD4-A4C9-7ACFEDBE8225}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D63255E7-7043-4AD4-A4C9-7ACFEDBE8225}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D63255E7-7043-4AD4-A4C9-7ACFEDBE8225}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D63255E7-7043-4AD4-A4C9-7ACFEDBE8225}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CA413A39-038F-4A9F-B56F-0E5413B6B158}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CA413A39-038F-4A9F-B56F-0E5413B6B158}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CA413A39-038F-4A9F-B56F-0E5413B6B158}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CA413A39-038F-4A9F-B56F-0E5413B6B158}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal

QuestPDF/Assembly.cs

@@ -1,6 +1,7 @@
 using System.Runtime.CompilerServices;
 
 [assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
+[assembly: InternalsVisibleTo("QuestPDF.Previewer")]
 [assembly: InternalsVisibleTo("QuestPDF.UnitTests")]
 [assembly: InternalsVisibleTo("QuestPDF.Examples")]
 [assembly: InternalsVisibleTo("QuestPDF.ReportSample")]

QuestPDF/Drawing/DocumentGenerator.cs

@@ -17,19 +17,30 @@ namespace QuestPDF.Drawing
     {
         internal static void GeneratePdf(Stream stream, IDocument document)
         {
+            CheckIfStreamIsCompatible(stream);
+            
             var metadata = document.GetMetadata();
-            var writeOnlyStream = new WriteOnlyStream(stream);
-            var canvas = new PdfCanvas(writeOnlyStream, metadata);
+            var canvas = new PdfCanvas(stream, metadata);
             RenderDocument(canvas, document);
         }
         
         internal static void GenerateXps(Stream stream, IDocument document)
         {
+            CheckIfStreamIsCompatible(stream);
+            
             var metadata = document.GetMetadata();
-            var writeOnlyStream = new WriteOnlyStream(stream);
-            var canvas = new XpsCanvas(writeOnlyStream, metadata);
+            var canvas = new XpsCanvas(stream, metadata);
             RenderDocument(canvas, document);
         }
+
+        private static void CheckIfStreamIsCompatible(Stream stream)
+        {
+            if (!stream.CanWrite)
+                throw new ArgumentException("The library requires a Stream object with the 'write' capability available (the CanWrite flag). Please consider using the MemoryStream class.");
+            
+            if (!stream.CanSeek)
+                throw new ArgumentException("The library requires a Stream object with the 'seek' capability available (the CanSeek flag). Please consider using the MemoryStream class.");
+        }
         
         internal static ICollection<byte[]> GenerateImages(IDocument document)
         {
@@ -40,7 +51,7 @@ namespace QuestPDF.Drawing
             return canvas.Images;
         }
 
-        private static void RenderDocument<TCanvas>(TCanvas canvas, IDocument document)
+        internal static void RenderDocument<TCanvas>(TCanvas canvas, IDocument document)
             where TCanvas : ICanvas, IRenderingCanvas
         {
             var container = new DocumentContainer();

QuestPDF/Drawing/FontManager.cs

@@ -52,7 +52,8 @@ namespace QuestPDF.Drawing
             {
                 return new SKPaint
                 {
-                    Color = SKColor.Parse(color)
+                    Color = SKColor.Parse(color),
+                    IsAntialias = true
                 };
             }
         }
@@ -67,7 +68,8 @@ namespace QuestPDF.Drawing
                 {
                     Color = SKColor.Parse(style.Color),
                     Typeface = GetTypeface(style),
-                    TextSize = style.Size ?? 12
+                    TextSize = style.Size ?? 12,
+                    IsAntialias = true,
                 };
             }
 

QuestPDF/Drawing/SkiaDocumentCanvasBase.cs

@@ -6,16 +6,16 @@ namespace QuestPDF.Drawing
 {
     internal class SkiaDocumentCanvasBase : SkiaCanvasBase
     {
-        private SKDocument Document { get; }
+        private SKDocument? Document { get; }
 
-        public SkiaDocumentCanvasBase(SKDocument document)
+        protected SkiaDocumentCanvasBase(SKDocument document)
         {
             Document = document;
         }
 
         ~SkiaDocumentCanvasBase()
         {
-            Document.Dispose();
+            Document?.Dispose();
         }
         
         public override void BeginDocument()
@@ -25,7 +25,7 @@ namespace QuestPDF.Drawing
 
         public override void EndDocument()
         {
-            Canvas.Dispose();
+            Canvas?.Dispose();
             
             Document.Close();
             Document.Dispose();

QuestPDF/Elements/Line.cs

@@ -25,8 +25,8 @@ namespace QuestPDF.Elements
         {
             return Type switch
             {
-                LineType.Vertical when availableSpace.Width >= Size => SpacePlan.FullRender(Size, 0),
-                LineType.Horizontal when availableSpace.Height >= Size => SpacePlan.FullRender(0, Size),
+                LineType.Vertical when availableSpace.Width + Infrastructure.Size.Epsilon >= Size => SpacePlan.FullRender(Size, 0),
+                LineType.Horizontal when availableSpace.Height + Infrastructure.Size.Epsilon >= Size => SpacePlan.FullRender(0, Size),
                 _ => SpacePlan.Wrap()
             };
         }

QuestPDF/Elements/Page.cs

@@ -30,6 +30,7 @@ namespace QuestPDF.Elements
         public void Compose(IContainer container)
         {
             container
+                .Background(BackgroundColor)
                 .Layers(layers =>
                 {
                     layers
@@ -44,9 +45,7 @@ namespace QuestPDF.Elements
                 
                         .MaxWidth(MaxSize.Width)
                         .MaxHeight(MaxSize.Height)
-                
-                        .Background(BackgroundColor)
-     
+
                         .PaddingLeft(MarginLeft)
                         .PaddingRight(MarginRight)
                         .PaddingTop(MarginTop)

QuestPDF/Elements/ScaleToFit.cs

@@ -17,8 +17,10 @@ namespace QuestPDF.Elements
             if (perfectScale == null)
                 return SpacePlan.Wrap();
 
-            var targetSpace = ScaleSize(availableSpace, perfectScale.Value);
-            return SpacePlan.FullRender(targetSpace);
+            var scaledSpace = ScaleSize(availableSpace, 1 / perfectScale.Value);
+            var childSizeInScale = Child.Measure(scaledSpace);
+            var childSizeInOriginalScale = ScaleSize(childSizeInScale, perfectScale.Value);
+            return SpacePlan.FullRender(childSizeInOriginalScale);
         }
         
         internal override void Draw(Size availableSpace)

QuestPDF/Elements/Text/Calculation/TextMeasurementRequest.cs

@@ -9,6 +9,6 @@ namespace QuestPDF.Elements.Text.Calculation
         
         public int StartIndex { get; set; }
         public float AvailableWidth { get; set; }
-        public bool IsFirstLineElement { get; set; }
+        public bool IsFirstElementInLine { get; set; }
     }
 }

QuestPDF/Elements/Text/Calculation/TextMeasurementResult.cs

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

QuestPDF/Elements/Text/Items/TextBlockPageNumber.cs

@@ -11,19 +11,19 @@ namespace QuestPDF.Elements.Text.Items
         
         public override TextMeasurementResult? Measure(TextMeasurementRequest request)
         {
-            SetPageNumber(request.PageContext);
+            UpdatePageNumberText(request.PageContext);
             return MeasureWithoutCache(request);
         }
 
         public override void Draw(TextDrawingRequest request)
         {
-            SetPageNumber(request.PageContext);
+            UpdatePageNumberText(request.PageContext);
             base.Draw(request);
         }
 
-        private void SetPageNumber(IPageContext context)
+        private void UpdatePageNumberText(IPageContext context)
         {
-            Text = Source(context) ?? PageNumberPlaceholder;
+            Text = Source(context) ?? string.Empty;
         }
     }
 }

QuestPDF/Elements/Text/Items/TextBlockSpan.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using QuestPDF.Drawing;
 using QuestPDF.Elements.Text.Calculation;
 using QuestPDF.Infrastructure;
@@ -11,13 +12,12 @@ namespace QuestPDF.Elements.Text.Items
         public string Text { get; set; }
         public TextStyle Style { get; set; } = new TextStyle();
 
-        private Dictionary<(int startIndex, float availableWidth), TextMeasurementResult?> MeasureCache =
-            new Dictionary<(int startIndex, float availableWidth), TextMeasurementResult?>();
+        private Dictionary<(int startIndex, float availableWidth), TextMeasurementResult?> MeasureCache = new ();
 
         public virtual TextMeasurementResult? Measure(TextMeasurementRequest request)
         {
             var cacheKey = (request.StartIndex, request.AvailableWidth);
-            
+             
             if (!MeasureCache.ContainsKey(cacheKey))
                 MeasureCache[cacheKey] = MeasureWithoutCache(request);
             
@@ -33,13 +33,15 @@ namespace QuestPDF.Elements.Text.Items
 
             var startIndex = request.StartIndex;
             
-            if (request.IsFirstLineElement)
+            // if the element is the first one within the line,
+            // ignore leading spaces
+            if (request.IsFirstElementInLine)
             {
-                while (startIndex + 1 < Text.Length && Text[startIndex] == space)
+                while (startIndex < Text.Length && Text[startIndex] == space)
                     startIndex++;
             }
-
-            if (Text.Length == 0)
+            
+            if (Text.Length == 0 || startIndex == Text.Length)
             {
                 return new TextMeasurementResult
                 {
@@ -52,38 +54,28 @@ namespace QuestPDF.Elements.Text.Items
             }
             
             // start breaking text from requested position
-            var text = Text.Substring(startIndex);
+            var text = Text.AsSpan().Slice(startIndex);
             
-            var textLength = (int)paint.BreakText(text, request.AvailableWidth);
+            var textLength = (int)paint.BreakText(text, request.AvailableWidth + Size.Epsilon);
 
             if (textLength <= 0)
                 return null;
-
-            if (textLength < text.Length && text[textLength] == space)
-                textLength++;
-            
+  
             // break text only on spaces
-            if (textLength < text.Length)
-            {
-                var lastSpaceIndex = text.Substring(0, textLength).LastIndexOf(space) - 1;
+            var wrappedTextLength = WrapText(text, textLength, request.IsFirstElementInLine);
 
-                if (lastSpaceIndex <= 0)
-                {
-                    if (!request.IsFirstLineElement)
-                        return null;
-                }
-                else
-                {
-                    textLength = lastSpaceIndex + 1;
-                }
-            }
+            if (wrappedTextLength == null)
+                return null;
 
-            text = text.Substring(0, textLength);
+            textLength = wrappedTextLength.Value;
+
+            text = text.Slice(0, textLength);
 
             var endIndex = startIndex + textLength;
             var nextIndex = endIndex;
 
-            while (nextIndex + 1 < Text.Length && Text[nextIndex] == space)
+            // when breaking text, omit spaces at the end of the line
+            while (nextIndex < Text.Length && Text[nextIndex] == space)
                 nextIndex++;
             
             // measure final text
@@ -103,6 +95,31 @@ namespace QuestPDF.Elements.Text.Items
                 NextIndex = nextIndex,
                 TotalIndex = Text.Length
             };
+
+            static int? WrapText(ReadOnlySpan<char> text, int textLength, bool isFirstElementInLine)
+            {
+                // textLength - length of the part of the text that fits in available width (creating a line)
+                
+                // entire text fits, no need to wrap
+                if (textLength == text.Length)
+                    return textLength;
+
+                // current line ends at word, next character is space, perfect place to wrap
+                if (text[textLength - 1] != space && text[textLength] == space)
+                    return textLength;
+                
+                // find last space within the available text to wrap
+                var lastSpaceIndex = text.Slice(0, textLength).LastIndexOf(space);
+
+                // text contains space that can be used to wrap
+                if (lastSpaceIndex > 0)
+                    return lastSpaceIndex;
+                
+                // there is no available space to wrap text
+                // if the item is first within the line, perform safe mode and chop the word
+                // otherwise, move the item into the next line
+                return isFirstElementInLine ? textLength : null;
+            }
         }
         
         public virtual void Draw(TextDrawingRequest request)

QuestPDF/Elements/Text/TextBlock.cs

@@ -170,7 +170,7 @@ namespace QuestPDF.Elements.Text
                         
                         StartIndex = currentItemIndex,
                         AvailableWidth = availableWidth - currentWidth,
-                        IsFirstLineElement = !currentLineElements.Any()
+                        IsFirstElementInLine = !currentLineElements.Any()
                     };
                 
                     var measurementResponse = currentElement.Measure(measurementRequest);

QuestPDF/Fluent/GenerateExtensions.cs

@@ -29,6 +29,8 @@ namespace QuestPDF.Fluent
         }
         
         #endregion
+
+        #region XPS
         
         public static byte[] GenerateXps(this IDocument document)
         {
@@ -48,8 +50,6 @@ namespace QuestPDF.Fluent
             DocumentGenerator.GenerateXps(stream, document);
         }
         
-        #region XPS
-        
         #endregion
 
         #region Images

QuestPDF/Fluent/PageExtensions.cs

@@ -88,11 +88,17 @@ namespace QuestPDF.Fluent
             DefaultTextStyle(handler(TextStyle.Default));
         }
         
-        public void Background(string color)
+        public void PageColor(string color)
         {
             Page.BackgroundColor = color;
         }
         
+        [Obsolete("This element has been renamed since version 2022.3. Please use the PageColor method.")]
+        public void Background(string color)
+        {
+            PageColor(color);
+        }
+        
         public IContainer Background()
         {
             var container = new Container();

QuestPDF/Fluent/TextExtensions.cs

@@ -24,7 +24,7 @@ namespace QuestPDF.Fluent
     
     public class TextPageNumberDescriptor : TextSpanDescriptor
     {
-        internal PageNumberFormatter FormatFunction { get; private set; } = x => (x ?? 123).ToString();
+        internal PageNumberFormatter FormatFunction { get; private set; } = x => x?.ToString() ?? string.Empty;
 
         internal TextPageNumberDescriptor(TextStyle textStyle) : base(textStyle)
         {
@@ -92,6 +92,10 @@ namespace QuestPDF.Fluent
         public TextSpanDescriptor Span(string? text)
         {
             var style = DefaultStyle.Clone();
+            var descriptor = new TextSpanDescriptor(style);
+
+            if (text == null)
+                return descriptor;
  
             var items = text
                 .Replace("\r", string.Empty)
@@ -114,7 +118,7 @@ namespace QuestPDF.Fluent
                 .ToList()
                 .ForEach(TextBlocks.Add);
 
-            return new TextSpanDescriptor(style);
+            return descriptor;
         }
 
         public TextSpanDescriptor Line(string? text)

QuestPDF/Fluent/TextStyleExtensions.cs

@@ -1,4 +1,5 @@
 using System;
+using System.ComponentModel;
 using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Fluent

QuestPDF/Helpers/WriteOnlyStream.cs

@@ -1,56 +0,0 @@
-using System;
-using System.IO;
-
-namespace QuestPDF.Helpers
-{
-    /// <summary>
-    /// SkiaSharp calls the Position property when generating target document file.
-    /// If the output stream does not support the Position property, the NullReferenceException is thrown.
-    /// This wrapper fixes this issue by providing cached Position value (always the end of the stream / current length).
-    /// Example stream affected: HttpContext.Response.Body
-    /// </summary>
-    internal class WriteOnlyStream : Stream
-    {
-        private readonly Stream InnerStream;
-        private long StreamLength { get; set; }
-
-        public WriteOnlyStream(Stream stream)
-        {            
-            if (!stream.CanWrite)
-                throw new NotSupportedException("Stream cannot be written");
-
-            InnerStream = stream;
-        }
-
-        public override bool CanRead => false;
-
-        public override bool CanSeek => false;
-
-        public override bool CanWrite => true;
-
-        public override long Length => StreamLength;
-
-        public override long Position
-        { 
-            get => StreamLength; 
-            set => throw new NotImplementedException(); 
-        }
-
-        public override void Flush() => InnerStream.Flush();
-
-        public override int Read(byte[] buffer, int offset, int count) 
-            => throw new NotImplementedException();
-
-        public override long Seek(long offset, SeekOrigin origin) 
-            => throw new NotImplementedException();
-
-        public override void SetLength(long value) 
-            => throw new NotImplementedException();
-
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            InnerStream.Write(buffer, offset, count);
-            StreamLength += count;
-        }
-    }
-}

QuestPDF/QuestPDF.csproj

@@ -4,7 +4,7 @@
         <Authors>MarcinZiabek</Authors>
         <Company>CodeFlint</Company>
         <PackageId>QuestPDF</PackageId>
-        <Version>2022.3.0</Version>
+        <Version>2022.3.1</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>
@@ -18,7 +18,7 @@
         <PackageTags>pdf report file export generate generation tool create creation render portable document format quest html library converter open source free standard core</PackageTags>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <Nullable>enable</Nullable>
-        <TargetFrameworks>net462;netstandard2.0;netcoreapp2.0;netcoreapp3.0</TargetFrameworks>
+        <TargetFrameworks>net462;netstandard2.0;netcoreapp2.0;netcoreapp3.0;net6.0</TargetFrameworks>
         <IncludeSymbols>true</IncludeSymbols>
         <SymbolPackageFormat>snupkg</SymbolPackageFormat>
     </PropertyGroup>

QuestPDF/Resources/Description.md

@@ -1,222 +1,95 @@
-## QuestPDF Overview
+[![Dotnet](https://img.shields.io/badge/platform-.NET-blue)](https://www.nuget.org/packages/QuestPDF/)
+[![GitHub Repo stars](https://img.shields.io/github/stars/QuestPDF/QuestPDF)](https://github.com/QuestPDF/QuestPDF/stargazers)
+[![Nuget version](https://img.shields.io/nuget/v/QuestPdf)](https://www.nuget.org/packages/QuestPDF/)
+[![Nuget download](https://img.shields.io/nuget/dt/QuestPDF)](https://www.nuget.org/packages/QuestPDF/)
+[![License](https://img.shields.io/github/license/QuestPDF/QuestPDF)](https://github.com/QuestPDF/QuestPDF/blob/main/LICENSE)
+[![Sponsor project](https://img.shields.io/badge/sponsor-project-red)](https://github.com/sponsors/QuestPDF)
 
-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.
+QuestPDF is an open-source .NET library for PDF documents generation.
 
-## Features
+It offers a layouting engine designed with a full paging support in mind. The document consists of many simple elements (e.g. border, background, image, text, padding, table, grid etc.) that are composed together to create more complex structures. This way, as a developer, you can understand the behavior of every element and use them with full confidence. Additionally, the document and all its elements support paging functionality. For example, an element can be moved to the next page (if there is not enough space) or even be split between pages like table's rows.
 
-**Rely on solid fundamentals** - This library is created specifically for designing and arranging document layouts, with full paging support.  Alternative solutions, such as HTML-based converters, are not designed for this purpose and therefore are often unpredictable and do not produce desired results.
+Unlike other libraries, it does not rely on the HTML-to-PDF conversion which in many cases is not reliable. Instead, it implements its own layouting engine that is optimized to cover all paging-related requirements.
 
-**Work with organized self-explanatory code** - The entire process of implementing PDF document, takes place in your code. Free yourself from slow visual designers and strange technological limitations. Follow simple yet highly effective approaches to create maintainable, high-quality code.
+## Installation
 
-**Compose simple components into complex documents** - Do you remember the feeling when your code just works? When your ideas are becoming real without any effort? Working with simple, easy to understand, self-explanatory and highly composable layout elements is the key here!
+The library is available as a nuget package. You can install it as any other nuget package from your IDE, try to search by `QuestPDF`. You can find package details [on this webpage](https://www.nuget.org/packages/QuestPDF/).
 
-**Create and reuse components** - Feel no fear of complex documents! Create custom, reusable components and divide the document's layout into easy to maintain pieces. Inject data to customize content and use slots to enhance composability. Decide how complex approaches your solution needs and follow the best path.
+```xml
+// Package Manager
+Install-Package QuestPDF
 
-**Prototype with ease** - We understand that document generation is often tricky and require multiple iterations. The library offers additional prototyping tools such as random text generator or image placeholder element. By following best practices, you can develop a document without having data.
+// .NET CLI
+dotnet add package QuestPDF
 
-**Enjoy fast PDF generation** - QuestPDF is created upon SkiaSharp, a well-known graphical library, and converts your data into PDF documents. It offers a highly optimized layouting engine capable of generating over 1000 PDF files per minute per core. The entire process is thread-safe.
+// Package reference in .csproj file
+<PackageReference Include="QuestPDF" Version="2022.3.0" />
+```
 
-## Learning resources
+## Documentation
 
-**[Release notes and roadmap](https://www.questpdf.com/documentation/releases.html)** - everything that is planned for future library iterations, description of new features and information about potential breaking changes.
-
-**[Getting started tutorial](https://www.questpdf.com/documentation/getting-started.html)** - a short and easy to follow tutorial showing how to design an invoice document under 200 lines of code.
-
-**[API Reference](https://www.questpdf.com/documentation/api-reference.html)** - a detailed description of behavior of all available components and how to use them with C# Fluent API.
-
-**[Patterns and practices](https://www.questpdf.com/documentation/patterns-and-practices.html#document-metadata)** - everything that may help you designing great reports and reusable code that is easy to maintain.
-
-## Example invoice
-
-Do you believe that creating a complete invoice document can take less than 200 lines of code? We have prepared for you a step-by-step instruction that shows every detail of this implementation and describes the best patterns and practices.
-
-For tutorial, documentation and API reference, please visit [the QuestPDF documentation](https://www.questpdf.com/documentation/getting-started.html).
-
-![invoice](https://raw.githubusercontent.com/QuestPDF/example-invoice/main/images/invoice.png)
-
-Here you can find an example code showing how easy is to write and understand the fluent API.
+[![Getting started tutorial]( https://img.shields.io/badge/%F0%9F%9A%80%20read-getting%20started-blue)](https://www.questpdf.com/documentation/getting-started.html)
+A short and easy to follow tutorial showing how to design an invoice document under 200 lines of code.
 
 
-**General document structure** with header, content and footer:
+[![API reference](https://img.shields.io/badge/%F0%9F%93%96%20read-API%20reference-blue)](https://www.questpdf.com/documentation/api-reference.html)
+A detailed description of behavior of all available components and how to use them with C# Fluent API.
 
-```csharp
-public void Compose(IDocumentContainer container)
+
+[![Patterns and Practices](https://img.shields.io/badge/%F0%9F%94%8D%20read-patterns%20and%20practices-blue)](https://www.questpdf.com/documentation/patterns-and-practices.html#document-metadata)
+Everything that may help you designing great reports and create reusable code that is easy to maintain.
+
+## Simplicity is the key
+
+How easy it is to start and prototype with QuestPDF? Really easy thanks to its minimal API! Please analyse the code below:
+
+```#
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+// code in your main method
+Document.Create(container =>
 {
-    container
-        .Page(page =>
-        {
-            page.Margin(50);
-            
-            page.Header().Element(ComposeHeader);
-            page.Content().Element(ComposeContent);
-            
-            page.Footer().AlignCenter().Text(x =>
+    container.Page(page =>
+    {
+        page.Size(PageSizes.A4);
+        page.Margin(2, Unit.Centimetre);
+        page.Background(Colors.White);
+        page.DefaultTextStyle(x => x.FontSize(20));
+        
+        page.Header()
+            .Text("Hello PDF!")
+            .SemiBold().FontSize(36).FontColor(Colors.Blue.Medium);
+        
+        page.Content()
+            .PaddingVertical(1, Unit.Centimetre)
+            .Column(x =>
             {
+                x.Spacing(20);
+                
+                x.Item().Text(Placeholders.LoremIpsum());
+                x.Item().Image(Placeholders.Image(200, 100));
+            });
+        
+        page.Footer()
+            .AlignCenter()
+            .Text(x =>
+            {
+                x.Span("Page ");
                 x.CurrentPageNumber();
-                x.Span(" / ");
-                x.TotalPages();
             });
-        });
-}
-```
-
-
-**The header area** consists of basic invoice information along with a logo placeholder.
-
-```csharp
-void ComposeHeader(IContainer container)
-{
-    var titleTextStyle = TextStyle.Default.Size(20).SemiBold().Color(Colors.Blue.Medium);
-    
-    container.Row(row =>
-    {
-        {
-            column.Item().Text($"Invoice #{Model.InvoiceNumber}", titleStyle);
-
-            column.Item().Text(text =>
-            {
-                text.Span("Issue date: ", TextStyle.Default.SemiBold());
-                text.Span($"{Model.IssueDate:d}");
-            });
-
-            column.Item().Text(text =>
-            {
-                text.Span("Due date: ", TextStyle.Default.SemiBold());
-                text.Span($"{Model.DueDate:d}");
-            });
-        });
-        
-        row.ConstantColumn(100).Height(50).Placeholder();
     });
-}
+})
+.GeneratePdf("hello.pdf");
 ```
 
+And compare it to the produced PDF file:
 
-Implementation of **the content area** that contains seller and customer details, then listing of all bought products, then a comments section.
+![invoice](https://raw.githubusercontent.com/QuestPDF/QuestPDF-Documentation/main/images/minimal-example-shadow.png)
 
-```csharp
-void ComposeContent(IContainer container)
-{
-    container.PaddingVertical(40).column(column => 
-    {
-        column.Spacing(20);
-        
-        column.Item().Row(row =>
-        {
-            row.RelativeColumn().Component(new AddressComponent("From", Model.SellerAddress));
-            row.ConstantColumn(50);
-            row.RelativeColumn().Component(new AddressComponent("For", Model.CustomerAddress));
-        });
+## Are you ready for more?
 
-        column.Item().Element(ComposeTable);
+The Fluent API of QuestPDF scales really well. It is easy to create and maintain even most complex documents. Read [the Getting started tutorial](https://www.questpdf.com/documentation/getting-started.html) to learn QuestPDF basics and implement an invoice under 200 lines of code. You can also investigate and play with the code from [the example repository](https://github.com/QuestPDF/example-invoice).
 
-        var totalPrice = Model.Items.Sum(x => x.Price * x.Quantity);
-        
-        column
-            .Item()
-            .PaddingRight(5)
-            .AlignRight()
-            .Text($"Grand total: {totalPrice}$", TextStyle.Default.SemiBold());
-
-        if (!string.IsNullOrWhiteSpace(Model.Comments))
-            column.Item().PaddingTop(25).Element(ComposeComments);
-    });
-}
-```
-
-
-**The table and comments** codes are extracted into separate methods to increase clarity:
-
-```csharp
-void ComposeTable(IContainer container)
-{
-    var headerStyle = TextStyle.Default.SemiBold();
-    
-    container.Table(table =>
-    {
-        table.ColumnsDefinition(columns =>
-        {
-            columns.ConstantColumn(25);
-            columns.RelativeColumn(3);
-            columns.RelativeColumn();
-            columns.RelativeColumn();
-            columns.RelativeColumn();
-        });
-        
-        table.Header(header =>
-        {
-            header.Cell().Text("#", headerStyle);
-            header.Cell().Text("Product", headerStyle);
-            header.Cell().AlignRight().Text("Unit price", headerStyle);
-            header.Cell().AlignRight().Text("Quantity", headerStyle);
-            header.Cell().AlignRight().Text("Total", headerStyle);
-            
-            header.Cell().ColumnSpan(5)
-                  .PaddingVertical(5).BorderBottom(1).BorderColor(Colors.Black);
-        });
-        
-        foreach (var item in Model.Items)
-        {
-            table.Cell().Element(CellStyle).Text(Model.Items.IndexOf(item) + 1);
-            table.Cell().Element(CellStyle).Text(item.Name);
-            table.Cell().Element(CellStyle).AlignRight().Text($"{item.Price}$");
-            table.Cell().Element(CellStyle).AlignRight().Text(item.Quantity);
-            table.Cell().Element(CellStyle).AlignRight().Text($"{item.Price * item.Quantity}$");
-            
-            static IContainer CellStyle(IContainer container)
-            {
-                container.BorderBottom(1).BorderColor(Colors.Grey.Lighten2).PaddingVertical(5);
-            }
-        }
-    });
-}
-```
-
-```csharp
-void ComposeComments(IContainer container)
-{
-    container.ShowEntire().Background(Colors.Grey.Lighten3).Padding(10).column(message => 
-    {
-        message.Spacing(5);
-        message.Item().Text("Comments", TextStyle.Default.Size(14).SemiBold());
-        message.Item().Text(Model.Comments);
-    });
-}
-```
-
-
-**The address details section** is implemented using components. This way the code can be easily reused for both seller and customer:
-
-```csharp
-public class AddressComponent : IComponent
-{
-    private string Title { get; }
-    private Address Address { get; }
-
-    public AddressComponent(string title, Address address)
-    {
-        Title = title;
-        Address = address;
-    }
-    
-    public void Compose(IContainer container)
-    {
-        container.ShowEntire().column(column =>
-        {
-            column.Spacing(5);
-
-            column
-                .Item()
-                .BorderBottom(1)
-                .PaddingBottom(5)
-                .Text(Title, TextStyle.Default.SemiBold());
-            
-            column.Item().Text(Address.CompanyName);
-            column.Item().Text(Address.Street);
-            column.Item().Text($"{Address.City}, {Address.State}");
-            column.Item().Text(Address.Email);
-            column.Item().Text(Address.Phone);
-        });
-    }
-}
-```
+![invoice](https://raw.githubusercontent.com/QuestPDF/QuestPDF-Documentation/main/images/invoice-small.png)

QuestPDF/Resources/ReleaseNotes.txt

@@ -1,8 +1,10 @@
-- Added a `ScaleToFit` element - scales its child down so it fits in the provided space,
-- Added a `StopPaging` element - when its child requires more than one page to fully render, only the first page is shown,
-- Added a 'LineVertical' and a 'LineHorizontal' elements - those will simplify your code a lot, there is no need to use the `Border` element anymore!
-- Renaming: the `Stack` element was renamed to the `Column` element,
-- Renaming: children of the `Row` element are now called `items` instead of `columns`, e.g. `RelativeItem` instead of `RelativeColumn`,
-- Added support of the `AutoItem` to the `Row` element - those items take as little width as possible,
-- Improved default Fluent configuration behavior for elements: Scale, Padding, Translate,
-- Improved integration support with the HttpContext.Response.Body. This improvement was introduced by schulz3000, thank you!
+- Added minimal API to help you quickly start with QuestPDF development and speed up prototyping,
+- Improved exception message when desired font type cannot be found (instead of loading default font on Windows and failing with wrong characters on Linux),
+- Improved support for custom font types: loading all type faces from a file, respecting true font family, using CSS-like algorithm to find best style match,
+- Added support for custom page number formats in the `Text` element, e.g. you can implement roman literal style if required,
+- Improved text API to make it more concise,
+- Extended support for the `Section` element (previously the `Location` element) by tracking: beginning page number, end page number, page length, page number within location,
+- Renaming: the `ExternalLink` element was renamed to the `Hyperlink` element,
+- Renaming: the `Location` element was renamed to the `Section` element,
+- Renaming: the `InternalLink` element was renamed to the `SectionLink` element,
+- Updated homepage and GitHub pages content.

readme.md

@@ -1,23 +1,51 @@
-<a href="https://www.questpdf.com/">
-  <img src="https://github.com/QuestPDF/example-invoice/raw/main/images/logo.svg" width="400px"> 
+<a href="https://www.questpdf.com/" target="_blank">
+  <img src="https://github.com/QuestPDF/example-invoice/raw/main/images/logo.svg" width="300"> 
 </a>
 
-QuestPDF presents a new approach to PDF document generation. Unlike other libraries, it does not rely on the HTML-to-PDF conversion which in many cases is not reliable. Instead, it implements its own layouting engine that is optimized to cover all paging-related requirements. Then, everything is rendered using the SkiaSharp library (a Skia port for .NET, used in Chrome, Android, MAUI, etc.).
+---
 
-I have designed this layouting engine with full paging support in mind. The document consists of many simple elements (e.g. border, background, image, text, padding, table, grid etc.) that are composed together to create more complex structures. This way, as a developer, you can understand the behaviour of every element and use them with full confidence. Additionally, the document and all its elements support paging functionality. For example, an element can be moved to the next page (if there is not enough space) or even be split between pages like table's rows.
+[![Dotnet](https://img.shields.io/badge/platform-.NET-blue)](https://www.nuget.org/packages/QuestPDF/)
+[![GitHub Repo stars](https://img.shields.io/github/stars/QuestPDF/QuestPDF)](https://github.com/QuestPDF/QuestPDF/stargazers)
+[![Nuget version](https://img.shields.io/nuget/v/QuestPdf)](https://www.nuget.org/packages/QuestPDF/)
+[![Nuget download](https://img.shields.io/nuget/dt/QuestPDF)](https://www.nuget.org/packages/QuestPDF/)
+[![License](https://img.shields.io/github/license/QuestPDF/QuestPDF)](https://github.com/QuestPDF/QuestPDF/blob/main/LICENSE)
+[![Sponsor project](https://img.shields.io/badge/sponsor-project-red)](https://github.com/sponsors/QuestPDF)
 
-## Support QuestPDF
+QuestPDF is an open-source .NET library for PDF documents generation.
 
-All great frameworks and libraries started from zero. Please help me make QuestPDF a commonly known library and an obvious choice for generating PDF documents. 
+It offers a layouting engine designed with a full paging support in mind. The document consists of many simple elements (e.g. border, background, image, text, padding, table, grid etc.) that are composed together to create more complex structures. This way, as a developer, you can understand the behavior of every element and use them with full confidence. Additionally, the document and all its elements support paging functionality. For example, an element can be moved to the next page (if there is not enough space) or even be split between pages like table's rows.
 
-- ⭐ Give this repository a star,
-- 💬 Share it with your team members. 
+Unlike other libraries, it does not rely on the HTML-to-PDF conversion which in many cases is not reliable. Instead, it implements its own layouting engine that is optimized to cover all paging-related requirements.
+
+## Please show the value
+
+Choosing a project dependency could be difficult. We need to ensure stability and maintainability of our projects. Surveys show that GitHub stars count play an important factor when assessing library quality. 
+
+⭐ Please give this repository a star. It takes seconds and help thousands of developers! ⭐
+
+## Please share with the community
+
+As an open-source project without funding, I cannot afford advertising QuestPDF in a typical way. Instead, the library relies on community interactions. Please consider sharing a post about QuestPDF and the value it provides. It really does help!
+
+[![GitHub Repo stars](https://img.shields.io/badge/share%20on-reddit-red?logo=reddit)](https://reddit.com/submit?url=https://github.com/QuestPDF/QuestPDF&title=QuestPDF)
+[![GitHub Repo stars](https://img.shields.io/badge/share%20on-hacker%20news-orange?logo=ycombinator)](https://news.ycombinator.com/submitlink?u=https://github.com/QuestPDF/QuestPDF)
+[![GitHub Repo stars](https://img.shields.io/badge/share%20on-twitter-03A9F4?logo=twitter)](https://twitter.com/share?url=https://github.com/QuestPDF/QuestPDF&t=QuestPDF)
+[![GitHub Repo stars](https://img.shields.io/badge/share%20on-facebook-1976D2?logo=facebook)](https://www.facebook.com/sharer/sharer.php?u=https://github.com/QuestPDF/QuestPDF)
+[![GitHub Repo stars](https://img.shields.io/badge/share%20on-linkedin-3949AB?logo=linkedin)](https://www.linkedin.com/shareArticle?url=https://github.com/QuestPDF/QuestPDF&title=QuestPDF)
+
+## Support development
+
+It doesn't matter if you are a professional developer, creating a startup or work for an established company. All of us care about our tools and dependencies, about stability and security, about time and money we can safe, about quality we can offer. Please consider sponsoring QuestPDF to give me an extra motivational push to develop the next great feature.
+
+> If you represent a company, want to help the entire community and show that you care, please consider sponsoring QuestPDF using one of the higher tiers. Your company logo will be shown here for all developers, building a strong positive relation.
+
+[![Sponsor project](https://img.shields.io/badge/%E2%9D%A4%EF%B8%8F%20sponsor-QuestPDF-red)](https://github.com/sponsors/QuestPDF)
 
 ## Installation
 
 The library is available as a nuget package. You can install it as any other nuget package from your IDE, try to search by `QuestPDF`. You can find package details [on this webpage](https://www.nuget.org/packages/QuestPDF/).
 
-```c#
+```xml
 // Package Manager
 Install-Package QuestPDF
 
@@ -25,16 +53,26 @@ Install-Package QuestPDF
 dotnet add package QuestPDF
 
 // Package reference in .csproj file
-<PackageReference Include="QuestPDF" Version="2022.2.5" />
+<PackageReference Include="QuestPDF" Version="2022.3.1" />
 ```
 
+[![Nuget version](https://img.shields.io/badge/package%20details-QuestPDF-blue?logo=nuget)](https://www.nuget.org/packages/QuestPDF/)
+
 ## Documentation
 
-**[🚀 Getting started tutorial](https://www.questpdf.com/documentation/getting-started.html)** - a short and easy to follow tutorial showing how to design an invoice document under 200 lines of code.
+[![Getting started tutorial]( https://img.shields.io/badge/%F0%9F%9A%80%20read-getting%20started-blue)](https://www.questpdf.com/documentation/getting-started.html)
+A short and easy to follow tutorial showing how to design an invoice document under 200 lines of code.
 
-**[📖 API Reference](https://www.questpdf.com/documentation/api-reference.html)** - a detailed description of behavior of all available components and how to use them with C# Fluent API.
 
-**[ℹ️ Patterns and practices](https://www.questpdf.com/documentation/patterns-and-practices.html#document-metadata)** - everything that may help you designing great reports and create reusable code that is easy to maintain.
+[![API reference](https://img.shields.io/badge/%F0%9F%93%96%20read-API%20reference-blue)](https://www.questpdf.com/documentation/api-reference.html)
+A detailed description of behavior of all available components and how to use them with C# Fluent API.
+
+
+[![Patterns and Practices](https://img.shields.io/badge/%F0%9F%94%8D%20read-patterns%20and%20practices-blue)](https://www.questpdf.com/documentation/patterns-and-practices.html#document-metadata)
+Everything that may help you designing great reports and create reusable code that is easy to maintain.
+
+
+<!-- 🚀 📖  ℹ️-->
 
 ## Simplicity is the key
 
@@ -53,10 +91,11 @@ Document.Create(container =>
         page.Size(PageSizes.A4);
         page.Margin(2, Unit.Centimetre);
         page.Background(Colors.White);
-        page.DefaultTextStyle(TextStyle.Default.Size(20));
+        page.DefaultTextStyle(x => x.FontSize(20));
         
         page.Header()
-            .Text("Hello PDF!", TextStyle.Default.SemiBold().Size(36).Color(Colors.Blue.Medium));
+            .Text("Hello PDF!")
+            .SemiBold().FontSize(36).FontColor(Colors.Blue.Medium);
         
         page.Content()
             .PaddingVertical(1, Unit.Centimetre)
@@ -82,10 +121,10 @@ Document.Create(container =>
 
 And compare it to the produced PDF file:
 
-
+<img src="https://raw.githubusercontent.com/QuestPDF/QuestPDF-Documentation/main/images/minimal-api.png" width="250px">
 
 ## Are you ready for more?
 
 The Fluent API of QuestPDF scales really well. It is easy to create and maintain even most complex documents. Read [the Getting started tutorial](https://www.questpdf.com/documentation/getting-started.html) to learn QuestPDF basics and implement an invoice under 200 lines of code. You can also investigate and play with the code from [the example repository](https://github.com/QuestPDF/example-invoice).
 
-<img src="https://github.com/QuestPDF/example-invoice/raw/main/images/invoice.png" width="595px">
+<img src="https://github.com/QuestPDF/example-invoice/raw/main/images/invoice.png" width="400px">