Size component cleanup

Merge 2021.6 for QuestPdf 2021.8

QuestPDF.Examples/BarcodeExamples.cs

@@ -0,0 +1,32 @@
+using NUnit.Framework;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples
+{
+    [TestFixture]
+    public class BarcodeExamples
+    {
+        [Test]
+        public void Barcode()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(300, 300)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Background("#FFF")
+                        .Padding(25)
+                        .Stack(stack =>
+                        {
+                            stack.Item().Border(1).Background(Colors.Grey.Lighten3).Padding(5).Text("Barcode Example");
+                            stack.Item().Border(1).Padding(5).AlignCenter().Text("*123456789*", TextStyle.Default.FontType("CarolinaBar-Demo-25E2").Size(20));
+                        });
+                });
+        }
+    }
+}

QuestPDF.Examples/ElementExamples.cs

@@ -1,138 +1,782 @@
+using System.Linq;
+using NUnit.Framework;
 using QuestPDF.Examples.Engine;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
+using SkiaSharp;
 
 namespace QuestPDF.Examples
 {
-    public class ElementExamples : ExampleTestBase
+    [TestFixture]
+    public class ElementExamples
     {
-        //[ShowResult]
-        [ImageSize(200, 150)]
-        public void Placeholder(IContainer container)
+        [Test]
+        public void Placeholder()
         {
-            container
-                .Background("#FFF")
-                .Padding(25)
-                .Placeholder();
-        }
-        
-        //[ShowResult]
-        [ImageSize(300, 300)]
-        public void Section(IContainer container)
-        {
-            container
-                .Background("#FFF")
-                .Padding(25)
-                .Section(section =>
+            RenderingTest
+                .Create()
+                .PageSize(200, 150)
+                .FileName()
+                .Render(container =>
                 {
-                    section
-                        .Header()
-                        .Background("#888")
-                        .Padding(10)
-                        .Text("Notes", TextStyle.Default.Size(16).Color("#FFF"));
-                    
-                    section
-                        .Content()
-                        .Background("#DDD")
-                        .Padding(10)
-                        .ExtendVertical()
-                        .Text(TextPlaceholder.LoremIpsum());
+                    container
+                        .Background("#FFF")
+                        .Padding(25)
+                        .Placeholder();
                 });
         }
         
-        //[ShowResult]
-        [ImageSize(298, 421)]
-        public void Page(IContainer container)
+        [Test]
+        public void Decoration()
         {
-            container
-                .Background("#FFF")
-                .Padding(15)
-                .Page(page =>
+            RenderingTest
+                .Create()
+                .PageSize(300, 300)
+                .FileName()
+                .Render(container =>
                 {
-                    page.Header()
-                        .Height(60)
-                        .Background("#BBB")
-                        .AlignCenter()
-                        .AlignMiddle()
-                        .Text("Header");
+                    container
+                        .Background("#FFF")
+                        .Padding(25)
+                        .Decoration(decoration =>
+                        {
+                            decoration
+                                .Header()
+                                .Background(Colors.Grey.Medium)
+                                .Padding(10)
+                                .Text("Notes", TextStyle.Default.Size(16).Color("#FFF"));
                     
-                    page.Content()
-                        .Background("#DDD")
-                        .AlignCenter()
-                        .AlignMiddle()
-                        .Text("Content");
+                            decoration
+                                .Content()
+                                .Background(Colors.Grey.Lighten3)
+                                .Padding(10)
+                                .ExtendVertical()
+                                .Text(Helpers.Placeholders.LoremIpsum());
+                        });
+                });
+        }
+
+        [Test]
+        public void Row()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(740, 200)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Background("#FFF")
+                        .Padding(20)
+                        .Stack(stack =>
+                        {
+                            stack.Item()
+                                .PaddingBottom(10)
+                                .AlignCenter()
+                                .Text("This Row element is 700pt wide");
+
+                            stack.Item().Row(row =>
+                            {
+                                row.ConstantColumn(100)
+                                    .Background(Colors.Grey.Lighten1)
+                                    .Padding(10)
+                                    .ExtendVertical()
+                                    .Text("This column is 100 pt wide");
+
+                                row.RelativeColumn()
+                                    .Background(Colors.Grey.Lighten2)
+                                    .Padding(10)
+                                    .Text("This column takes 1/3 of the available space (200pt)");
+
+                                row.RelativeColumn(2)
+                                    .Background(Colors.Grey.Lighten3)
+                                    .Padding(10)
+                                    .Text("This column takes 2/3 of the available space (400pt)");
+                            });
+                        });
+                });
+        }
+        
+        [Test]
+        public void RowSpacing()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(740, 200)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Background("#FFF")
+                        .Padding(20)
+                        .Row(row =>
+                        {
+                            row.Spacing(20);
+                            row.RelativeColumn(2).Border(1).Background(Colors.Grey.Lighten1);
+                            row.RelativeColumn(3).Border(1).Background(Colors.Grey.Lighten2);
+                            row.RelativeColumn(4).Border(1).Background(Colors.Grey.Lighten3);
+                        });
+                });
+        }
+    
+        [Test]
+        public void Stack()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(500, 360)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Background("#FFF")
+                        .Padding(15)
+                        .Stack(stack =>
+                        {
+                            stack.Spacing(15);
+                    
+                            stack.Item().Background(Colors.Grey.Medium).Height(50);
+                            stack.Item().Background(Colors.Grey.Lighten1).Height(100);
+                            stack.Item().Background(Colors.Grey.Lighten2).Height(150);
+                        });
+                });
+        }
+        
+        [Test]
+        public void Debug()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(210, 210)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Padding(25)
+                        .Debug("Grid example", Colors.Blue.Medium)
+                        .Grid(grid =>
+                        {
+                            grid.Columns(3);
+                            grid.Spacing(5);
+
+                            foreach (var _ in Enumerable.Range(0, 8))
+                                grid.Item().Height(50).Placeholder();
+                        });
+                });
+        }
+        
+        [Test]
+        public void ElementEnd()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(300, 200)
+                .FileName()
+                .Render(container =>
+                {
+                    var text = "";
+            
+                    container
+                        .Padding(10)
+                        .Element(x =>
+                        {
+                            if (string.IsNullOrWhiteSpace(text))
+                                x.Height(10).Width(50).Background("#DDD");
+                            else
+                                x.Text(text);
+                        });
+                });
+        }
+        
+        [Test]
+        public void GridExample()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(400, 230)
+                .FileName()
+                .Render(container =>
+                {
+                    var textStyle = TextStyle.Default.Size(14);
+            
+                    container
+                        .Padding(15)
+                        .AlignRight()
+                        .Grid(grid =>
+                        {
+                            grid.VerticalSpacing(10);
+                            grid.HorizontalSpacing(10);
+                            grid.AlignCenter();
+                            grid.Columns(10); // 12 by default
+
+                            grid.Item(6).Background(Colors.Blue.Lighten1).Height(50);
+                            grid.Item(4).Background(Colors.Blue.Lighten3).Height(50);
+                    
+                            grid.Item(2).Background(Colors.Teal.Lighten1).Height(70);
+                            grid.Item(3).Background(Colors.Teal.Lighten2).Height(70);
+                            grid.Item(5).Background(Colors.Teal.Lighten3).Height(70);
+                    
+                            grid.Item(2).Background(Colors.Green.Lighten1).Height(50);
+                            grid.Item(2).Background(Colors.Green.Lighten2).Height(50);
+                            grid.Item(2).Background(Colors.Green.Lighten3).Height(50);
+                        });
+                });
+        }
+        
+        [Test]
+        public void Canvas()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(300, 200)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Background("#FFF")
+                        .Padding(25)
+                        .Canvas((canvas, size) =>
+                        {
+                            using var paint = new SKPaint
+                            {
+                                Color = SKColors.Red,
+                                StrokeWidth = 10,
+                                IsStroke = true
+                            };
+                        
+                            // move origin to the center of the available space
+                            canvas.Translate(size.Width / 2, size.Height / 2);
+                    
+                            // draw a circle
+                            canvas.DrawCircle(0, 0, 50, paint);
+                        });
+                });
+        }
+ 
+        [Test]
+        public void LayersExample()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(400, 250)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Padding(25)
+                        .Layers(layers =>
+                        {
+                            // layer below main content
+                            layers
+                                .Layer()
+                                .Height(100)
+                                .Width(100)
+                                .Background(Colors.Grey.Lighten3);
+
+                            layers
+                                .PrimaryLayer()
+                                .Padding(25)
+                                .Stack(stack =>
+                                {
+                                    stack.Spacing(5);
+                            
+                                    foreach (var _ in Enumerable.Range(0, 7))
+                                        stack.Item().Text(Placeholders.Sentence());
+                                });
+                        
+                            // layer above the main content    
+                            layers
+                                .Layer()
+                                .AlignCenter()
+                                .AlignMiddle()
+                                .Text("Watermark", TextStyle.Default.Size(48).Bold().Color(Colors.Green.Lighten3));
+
+                            layers
+                                .Layer()
+                                .AlignBottom()
+                                .Text(text => text.CurrentPageNumber(TextStyle.Default.Size(16).Color(Colors.Green.Medium)));
+                        });
+                });
+        }
+
+        // [Test]
+        // public void EnsureSpace()
+        // {
+        //     RenderingTest
+        //         .Create()
+        //         .PageSize(300, 400)
+        //         .Render(container =>
+        //         {
+        //             container
+        //                 .Padding(50)
+        //                 .Page(page =>
+        //                 {
+        //                     page.Header().PageNumber("Page {pdf:currentPage}");
+        //             
+        //                     page.Content().Height(300).Stack(content =>
+        //                     {
+        //                         content.Item().Height(200).Background(Colors.Grey.Lighten2);
+        //                 
+        //                         content.Item().EnsureSpace(100).Stack(stack =>
+        //                         {
+        //                             stack.Spacing(10);
+        //                     
+        //                             foreach (var _ in Enumerable.Range(0, 4))
+        //                                 stack.Item().Height(50).Background(Colors.Green.Lighten1);
+        //                         }); 
+        //                     });
+        //                 });
+        //         });
+        // }
+
+        [Test]
+        public void RandomColorMatrix()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(300, 300)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Padding(25)
+                        .Grid(grid =>
+                        {
+                            grid.Columns(5);
+                    
+                            Enumerable
+                                .Range(0, 25)
+                                .Select(x => Placeholders.BackgroundColor())
+                                .ToList()
+                                .ForEach(x => grid.Item().Height(50).Background(x));
+                        });
+                });
+        }
+    
+        [Test]
+        public void DefinedColors()
+        {
+            var colors = new[]
+            {
+                Colors.Green.Darken4,
+                Colors.Green.Darken3,
+                Colors.Green.Darken2,
+                Colors.Green.Darken1,
+                
+                Colors.Green.Medium,
+                
+                Colors.Green.Lighten1,
+                Colors.Green.Lighten2,
+                Colors.Green.Lighten3,
+                Colors.Green.Lighten4,
+                Colors.Green.Lighten5,
+                
+                Colors.Green.Accent1,
+                Colors.Green.Accent2,
+                Colors.Green.Accent3,
+                Colors.Green.Accent4,
+            };
+            
+            RenderingTest
+                .Create()
+                .PageSize(450, 150)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Padding(25)
+                        .Height(100)
+                        .Row(row =>
+                        {
+                            foreach (var color in colors)
+                                row.RelativeColumn().Background(color);
+                        });
+                });
+        }
+
+        [Test]
+        public void DefinedFonts()
+        {
+            var fonts = new[]
+            {
+                Fonts.Calibri,
+                Fonts.Candara,
+                Fonts.Arial,
+                Fonts.TimesNewRoman,
+                Fonts.Consolas,
+                Fonts.Tahoma,
+                Fonts.Impact,
+                Fonts.Trebuchet,
+                Fonts.ComicSans
+            };
+            
+            RenderingTest
+                .Create()
+                .PageSize(500, 175)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Padding(25)
+                        .Grid(grid =>
+                        {
+                            grid.Columns(3);
+
+                            foreach (var font in fonts)
+                            {
+                                grid.Item()
+                                    .Border(1)
+                                    .BorderColor(Colors.Grey.Medium)
+                                    .Padding(10)
+                                    .Text(font, TextStyle.Default.FontType(font).Size(16));
+                            }
+                        });
+                });
+        }
+
+        [Test]
+        public void Layers()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(300, 300)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Background("#FFF")
+                        .Padding(25)
+                        .Layers(layers =>
+                        {
+                            layers.Layer().Text("Something else");
+                    
+                            layers.PrimaryLayer().Stack(stack =>
+                            {
+                                stack.Item().PaddingTop(20).Text("Text 1");
+                                stack.Item().PaddingTop(40).Text("Text 2");
+                            });
+                    
+                            layers.Layer().Canvas((canvas, size) =>
+                            {
+                                using var paint = new SKPaint
+                                {
+                                    Color = SKColors.Red,
+                                    StrokeWidth = 5
+                                };
+                        
+                                canvas.Translate(size.Width / 2, size.Height / 2);
+                                canvas.DrawCircle(0, 0, 50, paint);
+                            });
+                    
+                            layers.Layer().Background("#8F00").Extend();
+                            layers.Layer().PaddingTop(40).Text("It works!", TextStyle.Default.Size(24));
+                        });
+                });
+        }
+
+        [Test]
+        public void Box()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(300, 150)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Background("#FFF")
+                        .Padding(15)
+                        .Border(4)
+                        .BorderColor(Colors.Blue.Medium)
+                        //.Box()
+                        .Background(Colors.Grey.Lighten2)
+                        .Padding(15)
+                        .Text("Test of the \n box element", TextStyle.Default.Size(20));
+                });
+        }
+
+        [Test]
+        public void Scale()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(300, 175)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Background(Colors.White)
+                        .Padding(10)
+                        .Decoration(decoration =>
+                        {
+                            var headerFontStyle = TextStyle
+                                .Default
+                                .Size(20)
+                                .Color(Colors.Blue.Darken2)
+                                .SemiBold();
+    
+                            decoration
+                                .Header()
+                                .PaddingBottom(10)
+                                .Text("Example: scale component", headerFontStyle);
+    
+                            decoration
+                                .Content()
+                                .Stack(stack =>
+                                {
+                                    var scales = new[] { 0.8f, 0.9f, 1.1f, 1.2f };
+
+                                    foreach (var scale in scales)
+                                    {
+                                        var fontColor = scale <= 1f
+                                            ? Colors.Red.Lighten4
+                                            : Colors.Green.Lighten4;
+
+                                        var fontStyle = TextStyle.Default.Size(16);
+                
+                                        stack
+                                            .Item()
+                                            .Border(1)
+                                            .Background(fontColor)
+                                            .Scale(scale)
+                                            .Padding(5)
+                                            .Text($"Content with {scale} scale.", fontStyle);
+                                    }
+                                });
+                        });
+                });
+        }
+
+        [Test]
+        public void Translate()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(300, 200)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Background("#FFF")
+                        .Box()
+                        
+                        .Padding(25)
+                        
+                        .Background(Colors.Green.Lighten3)
+                        
+                        .TranslateX(15)
+                        .TranslateY(15)
+                        
+                        .Border(2)
+                        .BorderColor(Colors.Green.Darken1)
+                        
+                        .Padding(50)
+                        .Text("Moved text", TextStyle.Default.Size(25));
+                });
+        }
+
+        [Test]
+        public void ConstrainedRotate()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(350, 350)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Padding(20)
+                        .Grid(grid =>
+                        {
+                            grid.Columns(2);
+                            grid.Spacing(10);
+                            
+                            foreach (var turns in Enumerable.Range(0, 4))
+                            {
+                                grid.Item()
+                                    .Width(150)
+                                    .Height(150)
+                                    .Background(Colors.Grey.Lighten2)
+                                    .Padding(10)
+                                    .Element(element =>
+                                    {
+                                        foreach (var x in Enumerable.Range(0, turns))
+                                            element = element.RotateRight();
+
+                                        return element;
+                                    })
+                                    .Box()
+                                    .Background(Colors.White)
+                                    .Padding(10)
+                                    .Text($"Rotated {turns * 90}°", TextStyle.Default.Size(16));
+                            }
+                        });
+                });
+        }
+        
+        [Test]
+        public void FreeRotate()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(300, 300)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Padding(25)
+                        .Background(Colors.Grey.Lighten2)
                         
-                    page.Footer()
-                        .Height(30)
-                        .Background("#BBB")
                         .AlignCenter()
                         .AlignMiddle()
-                        .Text("Footer");
+                        
+                        
+                        .Background(Colors.White)
+                        
+                        .Rotate(30)
+
+                        .Width(100)
+                        .Height(100)
+                        .Background(Colors.Blue.Medium);
                 });
         }
         
-        //[ShowResult]
-        [ImageSize(740, 200)]
-        public void Row(IContainer container)
+        [Test]
+        public void FreeRotateCenter()
         {
-            container
-                .Background("#FFF")
-                .Padding(20)
-                .Stack(stack =>
+            RenderingTest
+                .Create()
+                .PageSize(300, 300)
+                .FileName()
+                .Render(container =>
                 {
-                    stack.Element()
-                        .PaddingBottom(10)
+                    container
+                        .Padding(25)
+                        .Background(Colors.Grey.Lighten2)
+                        
                         .AlignCenter()
-                        .Text("This Row element is 700pt wide");
+                        .AlignMiddle()
+                        
+                        .Background(Colors.White)
+                        
+                        .TranslateX(50)
+                        .TranslateY(50)
+                        
+                        .Rotate(30)
 
-                    stack.Element().Row(row =>
-                    {
-                        row.ConstantColumn(100)
-                            .Background("#DDD")
-                            .Padding(10)
-                            .ExtendVertical()
-                            .Text("This column is 100 pt wide");
+                        .TranslateX(-50)
+                        .TranslateY(-50)
+                        
+                        .Width(100)
+                        .Height(100)
+                        .Background(Colors.Blue.Medium);
+                });
+        }
 
-                        row.RelativeColumn()
-                            .Background("#BBB")
-                            .Padding(10)
-                            .Text("This column takes 1/3 of the available space (200pt)");
+        [Test]
+        public void Flip()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(350, 350)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Padding(20)
+                        .Grid(grid =>
+                        {
+                            grid.Columns(2);
+                            grid.Spacing(10);
+                            
+                            foreach (var turns in Enumerable.Range(0, 4))
+                            {
+                                grid.Item()
+                                    .Width(150)
+                                    .Height(150)
+                                    .Background(Colors.Grey.Lighten3)
+                                    .Padding(10)
+                                    .Element(element =>
+                                    {
+                                        if (turns == 1 || turns == 2)
+                                            element = element.FlipHorizontal();
 
-                        row.RelativeColumn(2)
-                            .Background("#DDD")
-                            .Padding(10)
-                            .Text("This column takes 2/3 of the available space (400pt)");
-                    });
+                                        if (turns == 2 || turns == 3)
+                                            element = element.FlipVertical();
+                                        
+                                        return element;
+                                    })
+                                    .Box()
+                                    .Background(Colors.White)
+                                    .Padding(10)
+                                    .Text($"Flipped {turns}", TextStyle.Default.Size(16));
+                            }
+                        });
                 });
         }
         
-        //[ShowResult]
-        [ImageSize(500, 350)]
-        public void Column(IContainer container)
+        [Test]
+        public void RotateInTable()
         {
-            container
-                .Background("#FFF")
-                .Padding(15)
-                .Stack(column =>
+            RenderingTest
+                .Create()
+                .PageSize(200, 200)
+                .FileName()
+                .Render(container =>
                 {
-                    column.Spacing(10);
-                    
-                    column
-                        .Element()
-                        .Background("#999")
-                        .Height(50);
-                    
-                    column
-                        .Element()
-                        .Background("#BBB")
-                        .Height(100);
-                    
-                    column
-                        .Element()
-                        .Background("#DDD")
-                        .Height(150);
+                    container
+                        .Padding(10)
+                        .Border(2)
+                        .Row(row =>
+                        {
+                            row.ConstantColumn(25)
+                                .Border(1)
+                                .RotateLeft()
+                                .AlignCenter()
+                                .AlignMiddle()
+                                .Text("Sample text");
+                            
+                            row.RelativeColumn().Border(1).Padding(5).Text(Placeholders.Paragraph());
+                        });
+                });
+        }
+        
+        [Test]
+        public void Unconstrained()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(400, 350)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Padding(25)
+                        .PaddingLeft(75)
+                        .Stack(stack =>
+                        {
+                            stack.Item().Width(300).Height(150).Background(Colors.Blue.Lighten4);
+                            
+                            stack
+                                .Item()
+                                
+                                // creates an infinite space for its child
+                                .Unconstrained()
+                                
+                                // moves the child up and left
+                                .TranslateX(-50)
+                                .TranslateY(-50)
+                                
+                                // limits the space for the child
+                                .Width(100)
+                                .Height(100)
+                                
+                                .Background(Colors.Blue.Darken1);
+                            
+                            stack.Item().Width(300).Height(150).Background(Colors.Blue.Lighten3);
+                        });
                 });
         }
     }
-}
+}

QuestPDF.Examples/Engine/ExampleTestBase.cs

@@ -1,89 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using NUnit.Framework;
-using QuestPDF.Drawing;
-using QuestPDF.Elements;
-using QuestPDF.Fluent;
-using QuestPDF.Infrastructure;
-using SkiaSharp;
-
-namespace QuestPDF.Examples.Engine
-{
-    [TestFixture]
-    public class ExampleTestBase
-    {
-        private readonly Size DefaultImageSize = new Size(400, 300);
-        private const string ResultPath = "Result";
-
-        [SetUp]
-        public void Setup()
-        {
-            if (Directory.Exists(ResultPath))
-                Directory.Delete(ResultPath, true);
-            
-            Directory.CreateDirectory(ResultPath);
-        }
-        
-        [Test]
-        public void RunTest()
-        {
-            GetType()
-                .GetMethods()
-                .Where(IsExampleMethod)
-                .ToList()
-                .ForEach(HandleExample);
-        }
-
-        private bool IsExampleMethod(MethodInfo method)
-        {
-            var parameters = method.GetParameters();
-            return parameters.Length == 1 && parameters.First().ParameterType == typeof(IContainer);
-        }
-        
-        private T GetAttribute<T>(MethodInfo methodInfo) where T : Attribute
-        {
-            return methodInfo.GetCustomAttributes().FirstOrDefault(y => y is T) as T;
-        }
-        
-        private void HandleExample(MethodInfo methodInfo)
-        {
-            var size = GetAttribute<ImageSizeAttribute>(methodInfo)?.Size ?? DefaultImageSize;
-            var fileName = GetAttribute<FileNameAttribute>(methodInfo)?.FileName ?? methodInfo.Name;
-            var showResult = GetAttribute<ShowResultAttribute>(methodInfo) != null;
-            var shouldIgnore = GetAttribute<IgnoreAttribute>(methodInfo) != null;
-
-            if (shouldIgnore)
-                return;
-            
-            var container = new Container();
-            methodInfo.Invoke(this, new object[] {container});
-
-            Func<int, string> fileNameSchema = i => $"{fileName.ToLower()}-${i}.png";
-            
-            var document = new SimpleDocument(container, size);
-            document.GenerateImages(fileNameSchema);
-            
-            if (showResult)
-                Process.Start("explorer", fileNameSchema(0));
-        }
-        
-        private byte[] RenderPage(Element element, Size size)
-        {
-            // scale the result so it is more readable
-            const float scalingFactor = 2;
-            
-            var imageInfo = new SKImageInfo((int)(size.Width * scalingFactor), (int)(size.Height * scalingFactor));
-            using var surface = SKSurface.Create(imageInfo);
-            surface.Canvas.Scale(scalingFactor);
-
-            var canvas = new Canvas(surface.Canvas);
-            element?.Draw(canvas, size);
-
-            surface.Canvas.Save();
-            return surface.Snapshot().Encode(SKEncodedImageFormat.Png, 100).ToArray();
-        }
-    }
-}

QuestPDF.Examples/Engine/FileNameAttribute.cs

@@ -1,14 +0,0 @@
-using System;
-
-namespace QuestPDF.Examples.Engine
-{
-    public class FileNameAttribute : Attribute
-    {
-        public string FileName { get; }
-
-        public FileNameAttribute(string fileName)
-        {
-            FileName = fileName;
-        }
-    }
-}

QuestPDF.Examples/Engine/IgnoreAttribute.cs

@@ -1,9 +0,0 @@
-using System;
-
-namespace QuestPDF.Examples.Engine
-{
-    public class IgnoreAttribute : Attribute
-    {
-        
-    }
-}

QuestPDF.Examples/Engine/ImageSizeAttribute.cs

@@ -1,19 +0,0 @@
-using System;
-using QuestPDF.Infrastructure;
-
-namespace QuestPDF.Examples.Engine
-{
-    public class ImageSizeAttribute : Attribute
-    {
-        private int Width { get; }
-        private int Height { get; }
-
-        public Size Size => new Size(Width, Height);
-        
-        public ImageSizeAttribute(int width, int height)
-        {
-            Width = width;
-            Height = height;
-        }
-    }
-}

QuestPDF.Examples/Engine/RenderingTest.cs

@@ -0,0 +1,95 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using QuestPDF.Elements;
+using QuestPDF.Fluent;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples.Engine
+{
+    public enum RenderingTestResult
+    {
+        Pdf,
+        Images
+    }
+    
+    public class RenderingTest
+    {
+        private string FileNamePrefix = "test";
+        private Size Size { get; set; }
+        private bool ShowResult { get; set; }
+        private RenderingTestResult ResultType { get; set; } = RenderingTestResult.Images;
+        
+        private RenderingTest()
+        {
+            
+        }
+
+        public static RenderingTest Create()
+        {
+            return new RenderingTest();
+        }
+
+        public RenderingTest FileName([CallerMemberName] string fileName = "test")
+        {
+            FileNamePrefix = fileName;
+            return this;
+        }
+        
+        public RenderingTest PageSize(Size size)
+        {
+            Size = size;
+            return this;
+        }
+        
+        public RenderingTest PageSize(int width, int height)
+        {
+            return PageSize(new Size(width, height));
+        }
+
+        public RenderingTest ProducePdf()
+        {
+            ResultType = RenderingTestResult.Pdf;
+            return this;
+        }
+        
+        public RenderingTest ProduceImages()
+        {
+            ResultType = RenderingTestResult.Images;
+            return this;
+        }
+
+        public RenderingTest ShowResults()
+        {
+            ShowResult = true;
+            return this;
+        }
+        
+        public void Render(Action<IContainer> content)
+        {
+            var container = new Container();
+            content(container);
+
+            var maxPages = ResultType == RenderingTestResult.Pdf ? 1000 : 10;
+            var document = new SimpleDocument(container, Size, maxPages);
+
+            if (ResultType == RenderingTestResult.Images)
+            {
+                Func<int, string> fileNameSchema = i => $"{FileNamePrefix}-${i}.png";
+                document.GenerateImages(fileNameSchema);
+                
+                if (ShowResult)
+                    Process.Start("explorer", fileNameSchema(0));
+            }
+
+            if (ResultType == RenderingTestResult.Pdf)
+            {
+                var fileName = $"{FileNamePrefix}.pdf";
+                document.GeneratePdf(fileName);
+                
+                if (ShowResult)
+                    Process.Start("explorer", fileName);
+            }
+        }
+    }
+}

QuestPDF.Examples/Engine/ShowResultAttribute.cs

@@ -1,9 +0,0 @@
-using System;
-
-namespace QuestPDF.Examples.Engine
-{
-    public class ShowResultAttribute : Attribute
-    {
-        
-    }
-}

QuestPDF.Examples/Engine/SimpleDocument.cs

@@ -1,4 +1,5 @@
 using QuestPDF.Drawing;
+using QuestPDF.Elements;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
@@ -7,27 +8,35 @@ namespace QuestPDF.Examples.Engine
 {
     public class SimpleDocument : IDocument
     {
+        public const int ImageScalingFactor = 2;
+        
         private IContainer Container { get; }
         private Size Size { get; }
+        private int MaxPages { get; }
 
-        public SimpleDocument(IContainer container, Size size)
+        public SimpleDocument(IContainer container, Size size, int maxPages)
         {
             Container = container;
             Size = size;
+            MaxPages = maxPages;
         }
         
         public DocumentMetadata GetMetadata()
         {
             return new DocumentMetadata()
             {
-                RasterDpi = PageSizes.PointsPerInch * 2,
-                Size = Size
+                RasterDpi = PageSizes.PointsPerInch * ImageScalingFactor,
+                DocumentLayoutExceptionThreshold = MaxPages
             };
         }
-
-        public void Compose(IContainer container)
+        
+        public void Compose(IDocumentContainer container)
         {
-            container.Element(Container.Child);
+            container.Page(page =>
+            {
+                page.Size(new PageSize(Size.Width, Size.Height));
+                page.Content().Container().Background(Colors.White).Element(Container as Container);
+            });
         }
     }
 }

QuestPDF.Examples/FrameExample.cs

@@ -1,4 +1,4 @@
-using System.Linq;
+using NUnit.Framework;
 using QuestPDF.Examples.Engine;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
@@ -20,25 +20,31 @@ namespace QuestPDF.Examples
         public static IContainer ValueCell(this IContainer container) => container.Cell(false);
     }
     
-    public class FrameExample: ExampleTestBase
+    public class FrameExample
     {
-        [ImageSize(550, 400)]
-        [ShowResult]
+        [Test]
         public void Frame(IContainer container)
         {
-            container
-                .Background("#FFF")
-                .Padding(25)
-                .Stack(stack =>
+            RenderingTest
+                .Create()
+                .PageSize(550, 400)
+                .FileName()
+                .Render(container =>
                 {
-                    for(var i=1; i<=4; i++)
-                    {
-                        stack.Element().Row(row =>
+                    container
+                        .Background("#FFF")
+                        .Padding(25)
+                        .Stack(stack =>
                         {
-                            row.RelativeColumn(2).LabelCell().Text(TextPlaceholder.Label());
-                            row.RelativeColumn(3).ValueCell().Text(TextPlaceholder.Paragraph());
+                            for(var i=1; i<=4; i++)
+                            {
+                                stack.Item().Row(row =>
+                                {
+                                    row.RelativeColumn(2).LabelCell().Text(Placeholders.Label());
+                                    row.RelativeColumn(3).ValueCell().Text(Placeholders.Paragraph());
+                                });
+                            }
                         });
-                    }
                 });
         }
     }

QuestPDF.Examples/LoremPicsumExample.cs

@@ -1,4 +1,5 @@
 using System.Net;
+using NUnit.Framework;
 using QuestPDF.Examples.Engine;
 using QuestPDF.Fluent;
 using QuestPDF.Infrastructure;
@@ -27,27 +28,33 @@ namespace QuestPDF.Examples
         }
     }
     
-    public class LoremPicsumExample : ExampleTestBase
+    public class LoremPicsumExample
     {
-        [ShowResult]
-        [ImageSize(350, 280)]
-        public void LoremPicsum(IContainer container)
+        [Test]
+        public void LoremPicsum()
         {
-            container
-                .Background("#FFF")
-                .Padding(25)
-                .Stack(column =>
+            RenderingTest
+                .Create()
+                .PageSize(350, 280)
+                .FileName()
+                .Render(container =>
                 {
-                    column.Spacing(10);
+                    container
+                        .Background("#FFF")
+                        .Padding(25)
+                        .Stack(column =>
+                        {
+                            column.Spacing(10);
 
-                    column
-                        .Element()
-                        .Component(new LoremPicsum(true));
+                            column
+                                .Item()
+                                .Component(new LoremPicsum(true));
                     
-                    column
-                        .Element()
-                        .AlignRight()
-                        .Text("From Lorem Picsum");
+                            column
+                                .Item()
+                                .AlignRight()
+                                .Text("From Lorem Picsum");
+                        });
                 });
         }
     }

QuestPDF.Examples/Padding.cs

@@ -1,132 +1,166 @@
-using QuestPDF.Examples.Engine;
+using NUnit.Framework;
+using QuestPDF.Examples.Engine;
 using QuestPDF.Fluent;
 using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Examples
 {
-    public class Examples : ExampleTestBase
+    public class Examples
     {
-        public void Padding(IContainer container)
+        [Test]
+        public void Padding()
         {
-            container
-                .Background("#FDD")
-                .Padding(50)
-
-                .Background("#AFA")
-                .PaddingVertical(50)
-
-                .Background("#77F")
-                .PaddingHorizontal(50)
-
-                .Background("#444");
-        }
-        
-        public void Border(IContainer container)
-        {
-            container
-                .Background("#EEE")
-                .Padding(25)
-
-                .AlignBottom()
-                .AlignCenter()
-                .BorderBottom(2)
-                .BorderColor("#000")
-                
-                .Background("FFF")
-                .Padding(5)
-                .Text("Sample text", TextStyle.Default.FontType("Segoe UI emoji").Alignment(HorizontalAlignment.Center));
-        }
-        
-        public void Alignment(IContainer container)
-        {
-            container
-                .Stack(column =>
+            RenderingTest
+                .Create()
+                .PageSize(200, 150)
+                .FileName()
+                .Render(container =>
                 {
-                    column
-                        .Element()
-                        .Height(100)
-                        .Background("#FFF")
-                        
-                        .AlignLeft()
-                        .AlignMiddle()
+                    container
+                        .Background("#FDD")
+                        .Padding(50)
+
+                        .Background("#AFA")
+                        .PaddingVertical(50)
+
+                        .Background("#77F")
+                        .PaddingHorizontal(50)
 
-                        .Width(50)
-                        .Height(50)
                         .Background("#444");
-                    
-                    column
-                        .Element()
-                        .Height(100)
-                        .Background("#DDD")
-                        
-                        .AlignCenter()
-                        .AlignMiddle()
-
-                        .Width(50)
-                        .Height(50)
-                        .Background("#222");
-                    
-                    column
-                        .Element()
-                        .Height(100)
-                        .Background("#BBB")
-                        
-                        .AlignRight()
-                        .AlignMiddle()
-
-                        .Width(50)
-                        .Height(50)
-                        .Background("#000");
                 });
         }
         
-        public void Expand(IContainer container)
+        [Test]
+        public void Border()
         {
-            container
-                .Stack(column =>
+            RenderingTest
+                .Create()
+                .PageSize(200, 150)
+                .FileName()
+                .Render(container =>
                 {
-                    column
-                        .Element()
-                        .Height(150)
-                        .Row(row =>
+                    container
+                        .Background("#EEE")
+                        .Padding(25)
+
+                        .AlignBottom()
+                        .AlignCenter()
+                        .BorderBottom(2)
+                        .BorderColor("#000")
+                
+                        .Background("FFF")
+                        .Padding(5)
+                        .AlignCenter()
+                        .Text("Sample text", TextStyle.Default.FontType("Segoe UI emoji"));
+                });
+        }
+        
+        [Test]
+        public void Alignment()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(200, 150)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Stack(column =>
                         {
-                            row.RelativeColumn()
-                                .Extend()
-                                .Background("FFF")
+                            column
+                                .Item()
+                                .Height(100)
+                                .Background("#FFF")
+                        
+                                .AlignLeft()
+                                .AlignMiddle()
 
-                                .Height(50)
                                 .Width(50)
-                                .Background("444");
-                            
-                            row.RelativeColumn()
-                                .Extend()
-                                .Background("BBB")
-
                                 .Height(50)
-                                .ExtendHorizontal()
-                                .Background("444");
-                        });
+                                .Background("#444");
                     
-                    column
-                        .Element()
-                        .Height(150)
-                        .Row(row =>
-                        {
-                            row.RelativeColumn()
-                                .Extend()
-                                .Background("BBB")
+                            column
+                                .Item()
+                                .Height(100)
+                                .Background("#DDD")
+                        
+                                .AlignCenter()
+                                .AlignMiddle()
 
-                                .ExtendVertical()
                                 .Width(50)
-                                .Background("444");
-                            
-                            row.RelativeColumn()
-                                .Extend()
-                                .Background("BBB")
+                                .Height(50)
+                                .Background("#222");
+                    
+                            column
+                                .Item()
+                                .Height(100)
+                                .Background("#BBB")
+                        
+                                .AlignRight()
+                                .AlignMiddle()
 
-                                .ExtendVertical()
-                                .ExtendHorizontal()
-                                .Background("444");
+                                .Width(50)
+                                .Height(50)
+                                .Background("#000");
+                        });
+                });
+        }
+        
+        [Test]
+        public void Expand()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(200, 150)
+                .FileName()
+                .Render(container =>
+                {
+                    container
+                        .Stack(column =>
+                        {
+                            column
+                                .Item()
+                                .Height(150)
+                                .Row(row =>
+                                {
+                                    row.RelativeColumn()
+                                        .Extend()
+                                        .Background("FFF")
+
+                                        .Height(50)
+                                        .Width(50)
+                                        .Background("444");
+                            
+                                    row.RelativeColumn()
+                                        .Extend()
+                                        .Background("BBB")
+
+                                        .Height(50)
+                                        .ExtendHorizontal()
+                                        .Background("444");
+                                });
+                    
+                            column
+                                .Item()
+                                .Height(150)
+                                .Row(row =>
+                                {
+                                    row.RelativeColumn()
+                                        .Extend()
+                                        .Background("BBB")
+
+                                        .ExtendVertical()
+                                        .Width(50)
+                                        .Background("444");
+                            
+                                    row.RelativeColumn()
+                                        .Extend()
+                                        .Background("BBB")
+
+                                        .ExtendVertical()
+                                        .ExtendHorizontal()
+                                        .Background("444");
+                                });
                         });
                 });
         }

QuestPDF.Examples/QuestPDF.Examples.csproj

@@ -13,8 +13,13 @@
     </ItemGroup>
 
     <ItemGroup>
-      <ProjectReference Include="..\QuestPDF.InvoiceSample\QuestPDF.InvoiceSample.csproj" />
       <ProjectReference Include="..\QuestPDF\QuestPDF.csproj" />
     </ItemGroup>
 
+    <ItemGroup>
+      <None Update="quo-vadis.txt">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+    </ItemGroup>
+
 </Project>

QuestPDF.Examples/TextBenchmark.cs

@@ -0,0 +1,228 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using NUnit.Framework;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples
+{
+    public class TextBenchmark
+    {
+        [Test]
+        public void Generate()
+        {
+            var chapters = GetBookChapters().ToList();
+            
+            RenderingTest
+                .Create()
+                .PageSize(PageSizes.A4)
+                .FileName()
+                .ProducePdf()
+                .ShowResults()
+                .Render(x => ComposeBook(x, chapters));
+        }
+        
+        [Test]
+        public void Benchmark()
+        {
+            var chapters = GetBookChapters().ToList();
+  
+            var results = PerformTest(16).ToList();
+ 
+            Console.WriteLine($"Min: {results.Min():F}");
+            Console.WriteLine($"Max: {results.Max():F}");
+            Console.WriteLine($"Avg: {results.Average():F}");
+            
+            void GenerateDocument()
+            {
+                RenderingTest
+                    .Create()
+                    .PageSize(PageSizes.A4)
+                    .FileName()
+                    .ProducePdf()
+                    .Render(x => ComposeBook(x, chapters));
+            }
+
+            IEnumerable<float> PerformTest(int attempts)
+            {
+                foreach (var i in Enumerable.Range(0, attempts))
+                {
+                    var timer = new Stopwatch();
+                
+                    timer.Start();
+                    GenerateDocument();
+                    timer.Stop();
+
+                    Console.WriteLine($"Attempt {i}: {timer.ElapsedMilliseconds:F}");
+                    yield return timer.ElapsedMilliseconds;
+                }
+            }
+        }
+
+        class BookChapter
+        {
+            public string Title { get; set; }
+            public string Content { get; set; }
+        }
+        
+        private static IEnumerable<BookChapter> GetBookChapters()
+        {
+            var book = File.ReadAllLines("quo-vadis.txt");
+            
+            var chapterPointers = book
+                .Select((line, index) => new
+                {
+                    LineNumber = index,
+                    Text = line
+                })
+                .Where(x => x.Text.Length < 50 && x.Text.Contains("Rozdział") || x.Text.Contains("-----"))
+                .Select(x => x.LineNumber)
+                .ToList();
+
+            foreach (var index in Enumerable.Range(0, chapterPointers.Count - 1))
+            {
+                var chapter = chapterPointers[index];
+                    
+                var title = book[chapter];
+                    
+                var lineFrom = chapterPointers[index];
+                var lineTo = chapterPointers[index + 1] - 1;
+
+                var lines = book.Skip(lineFrom + 1).Take(lineTo - lineFrom).Where(x => !string.IsNullOrWhiteSpace(x));
+                var content = string.Join(Environment.NewLine, lines);
+
+                yield return new BookChapter
+                {
+                    Title = title,
+                    Content = content
+                };
+            }
+        }
+        
+        private void ComposeBook(IContainer 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
+                    .Padding(50)
+                    .Decoration(decoration =>
+                    {
+                        decoration
+                            .Content()
+                            .Stack(stack =>
+                            {
+                                stack.Item().Element(Title);
+                                stack.Item().PageBreak();
+                                stack.Item().Element(TableOfContents);
+                                stack.Item().PageBreak();
+
+                                Chapters(stack);
+
+                                stack.Item().Element(Acknowledgements);
+                            });
+
+                        decoration.Footer().Element(Footer);
+                    });
+            }
+            
+            void Title(IContainer container)
+            {
+                container
+                    .Extend()
+                    .PaddingBottom(200)
+                    .AlignBottom()
+                    .Stack(stack =>
+                    {
+                        stack.Item().Text("Quo Vadis", TextStyle.Default.Size(72).Bold().Color(Colors.Blue.Darken2));
+                        stack.Item().Text("Henryk Sienkiewicz", TextStyle.Default.Size(24).Color(Colors.Grey.Darken2));
+                    });
+            }
+
+            void TableOfContents(IContainer container)
+            {
+                container.Stack(stack =>
+                {
+                    SectionTitle(stack, "Spis treści");
+                    
+                    foreach (var chapter in chapters)
+                    {
+                        stack.Item().InternalLink(chapter.Title).Row(row =>
+                        {
+                            row.RelativeColumn().Text(chapter.Title, normalStyle);
+                            row.ConstantColumn(100).AlignRight().Text(text => text.PageNumberOfLocation(chapter.Title, normalStyle));
+                        });
+                    }
+                });
+            }
+
+            void Chapters(StackDescriptor stack)
+            {
+                foreach (var chapter in chapters)
+                {
+                    stack.Item().Element(container => Chapter(container, chapter.Title, chapter.Content));
+                }
+            }
+            
+            void Chapter(IContainer container, string title, string content)
+            {
+                container.Stack(stack =>
+                {
+                    SectionTitle(stack, title);
+  
+                    stack.Item().Text(text =>
+                    {
+                        text.ParagraphSpacing(5);
+                        text.Span(content, normalStyle);
+                    });
+                    
+                    stack.Item().PageBreak();
+                });
+            }
+
+            void Acknowledgements(IContainer container)
+            {
+                container.Stack(stack =>
+                {
+                    SectionTitle(stack, "Podziękowania");
+                    
+                    stack.Item().Text(text =>
+                    {
+                        text.DefaultTextStyle(normalStyle);
+                        
+                        text.Span("Ten dokument został wygenerowany na podstawie książki w formacie TXT opublikowanej w serwisie ");
+                        text.ExternalLocation("wolnelektury.pl", "https://wolnelektury.pl/", normalStyle.Color(Colors.Blue.Medium).Underlined());
+                        text.Span(". Dziękuję za wspieranie polskiego czytelnictwa!");
+                    });
+                });
+            }
+
+            void SectionTitle(StackDescriptor stack, string text)
+            {
+                stack.Item().Location(text).Text(text, subtitleStyle);
+                stack.Item().PaddingTop(10).PaddingBottom(50).BorderBottom(1).BorderColor(Colors.Grey.Lighten2).ExtendHorizontal();
+            }
+            
+            void Footer(IContainer container)
+            {
+                container
+                    .AlignCenter()
+                    .Text(text =>
+                    {
+                        text.CurrentPageNumber();
+                        text.Span(" / ");
+                        text.TotalPages();
+                    });
+            }
+        }
+    }
+}

QuestPDF.Examples/TextExamples.cs

@@ -0,0 +1,122 @@
+using System;
+using System.Linq;
+using NUnit.Framework;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples
+{
+    public class TextExamples
+    {
+        [Test]
+        public void TextElements()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(500, 400)
+                .FileName()
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(10)
+                        .Box()
+                        .Border(1)
+                        .Padding(10)
+                        .Text(text =>
+                        {
+                            text.DefaultTextStyle(TextStyle.Default);
+                            text.AlignLeft();
+                            text.ParagraphSpacing(10);
+                            
+                            text.Span(Placeholders.LoremIpsum());
+                            
+                            text.NewLine();
+                            
+                            text.Span("This text is a normal text, ");
+                            text.Span("this is a bold text, ", TextStyle.Default.Bold());
+                            text.Span("this is a red and underlined text, ", TextStyle.Default.Color(Colors.Red.Medium).Underlined());
+                            text.Span("and this is slightly bigger text.", TextStyle.Default.Size(16));
+                            
+                            text.NewLine();
+                            
+                            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.Span(".");
+                            
+                            text.NewLine();
+                            
+                            text.Span("This is page number ");
+                            text.CurrentPageNumber();
+                            text.Span(" out of ");
+                            text.TotalPages();
+                            
+                            text.NewLine();
+                            
+                            text.ExternalLocation("Please visit QuestPDF website", "https://www.questpdf.com");
+                            
+                            text.NewLine();
+                            
+                            /*
+                            text.Span("Let's start with bold text. ", TextStyle.Default.Bold().BackgroundColor(Colors.Grey.Lighten3).Size(16));
+                            text.Span("Then something bigger. ", TextStyle.Default.Size(28).Color(Colors.DeepOrange.Darken2).BackgroundColor(Colors.Yellow.Lighten3).Underlined());
+                            text.Span("And tiny \r\n teeny-tiny. ", TextStyle.Default.Size(6));
+                            text.Span("Stroked text also works fine. ", TextStyle.Default.Size(14).Stroked().BackgroundColor(Colors.Grey.Lighten4));
+                               
+                            text.Span("0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789", TextStyle.Default.Size(18));
+                            
+                            text.NewLine();
+                            text.NewLine();
+                            text.NewLine();
+                            text.Span("Is it time for lorem  ipsum? ", TextStyle.Default.Size(12).Underlined().BackgroundColor(Colors.Grey.Lighten3));
+                            text.Span(Placeholders.LoremIpsum(), TextStyle.Default.Size(12));
+                            
+                            text.Span("Before element - ");
+                            text.Element().PaddingBottom(-10).Background(Colors.Red.Lighten4).Height(20).PaddingHorizontal(5).AlignMiddle().Text("Text inside text", TextStyle.Default.Size(8));
+                            text.Span(" - end of element.");
+                            
+                            text.NewLine();
+                            // text.Span("And now some colors: ", TextStyle.Default.Size(16).Color(Colors.Green.Medium));
+                            //
+                            // foreach (var i in Enumerable.Range(1, 100))
+                            // {
+                            //     text.Span($"{i}: {Placeholders.Sentence()} ", TextStyle.Default.Size(12 + i / 5).LineHeight(2.75f - i / 50f).Color(Placeholders.Color()).BackgroundColor(Placeholders.BackgroundColor()));   
+                            // }*/
+                        });
+                });
+        }
+
+        [Test]
+        public void PageNumber()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(500, 400)
+                .FileName()
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(10)
+                        .Box()
+                        .Border(1)
+                        .Padding(10)
+                        .Text(text =>
+                        {
+                            text.DefaultTextStyle(TextStyle.Default);
+                            text.AlignLeft();
+                            text.ParagraphSpacing(10);
+
+                            text.Span("This is page number ");
+                            text.CurrentPageNumber();
+                            text.Span(" out of ");
+                            text.TotalPages();
+                        });
+                });
+        }
+    }
+}

QuestPDF.ReportSample/DataSource.cs

@@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using QuestPDF.Helpers;
-using QuestPDF.ReportSample.Layouts;
 
 namespace QuestPDF.ReportSample
 {
@@ -18,9 +17,9 @@ namespace QuestPDF.ReportSample
                 Title = "Sample Report Document",
                 HeaderFields = HeaderFields(),
                 
-                LogoData = Helpers.GetImage("logo.png"),
-                Sections = Enumerable.Range(0, 10).Select(x => GenerateSection()).ToList(),
-                Photos = Enumerable.Range(0, 10).Select(x => GetReportPhotos()).ToList()
+                LogoData = Helpers.GetImage("Logo.png"),
+                Sections = Enumerable.Range(0, 40).Select(x => GenerateSection()).ToList(),
+                Photos = Enumerable.Range(0, 25).Select(x => GetReportPhotos()).ToList()
             };
 
             List<ReportHeaderField> HeaderFields()
@@ -41,6 +40,11 @@ namespace QuestPDF.ReportSample
                     {
                         Label = "Date",
                         Value = DateTime.Now.ToString("g")
+                    },
+                    new ReportHeaderField()
+                    {
+                        Label = "Status",
+                        Value = "Completed, found 2 issues"
                     }
                 };
             }
@@ -48,12 +52,12 @@ namespace QuestPDF.ReportSample
             ReportSection GenerateSection()
             {
                 var sectionLength = Helpers.Random.NextDouble() > 0.75
-                    ? Helpers.Random.Next(10, 20)
-                    : Helpers.Random.Next(3, 11);
+                    ? Helpers.Random.Next(20, 40)
+                    : Helpers.Random.Next(5, 10);
                 
                 return new ReportSection
                 {
-                    Title = TextPlaceholder.Label(),
+                    Title = Placeholders.Label(),
                     Parts = Enumerable.Range(0, sectionLength).Select(x => GetRandomElement()).ToList()
                 };
             }
@@ -62,10 +66,10 @@ namespace QuestPDF.ReportSample
             {
                 var random = Helpers.Random.NextDouble();
 
-                if (random < 0.8f)
+                if (random < 0.9f)
                     return GetTextElement();
                 
-                if (random < 0.9f)
+                if (random < 0.95f)
                     return GetMapElement();
                 
                 return GetPhotosElement();
@@ -75,19 +79,17 @@ namespace QuestPDF.ReportSample
             {
                 return new ReportSectionText
                 {
-                    Label = TextPlaceholder.Label(),
-                    Text = TextPlaceholder.Paragraph()
+                    Label = Placeholders.Label(),
+                    Text = Placeholders.Paragraph()
                 };
             }
             
             ReportSectionMap GetMapElement()
             {
-                var rnd = Helpers.Random.Next(0, 64);
-                    
                 return new ReportSectionMap
                 {
                     Label = "Location",
-                    ImageSource = x => Helpers.GetDocumentMap($"{rnd}.jpg"),
+                    ImageSource = Placeholders.Image,
                     Location = Helpers.RandomLocation()
                 };
             }
@@ -98,28 +100,24 @@ namespace QuestPDF.ReportSample
                 {    
                     Label = "Photos",
                     Photos = Enumerable
-                        .Range(0, Helpers.Random.Next(1, 10))
-                        .Select(x => Helpers.Random.Next(0, 128))
-                        .Select(x => Helpers.GetPhoto($"{x}.jpg"))
+                        .Range(0, Helpers.Random.Next(1, 15))
+                        .Select(x => Placeholders.Image(400, 300))
                         .ToList()
                 };
             }
 
             ReportPhoto GetReportPhotos()
             {
-                var photoId = Helpers.Random.Next(0, 128);
-                var mapId = Helpers.Random.Next(0, 64);
-
                 return new ReportPhoto()
                 {
-                    PhotoData = Helpers.GetPhoto($"{photoId}.jpg"),
+                    PhotoData = Placeholders.Image(800, 600),
 
-                    Comments = TextPlaceholder.Paragraph(),
+                    Comments = Placeholders.Sentence(),
                     Date = DateTime.Now - TimeSpan.FromDays(Helpers.Random.NextDouble() * 100),
                     Location = Helpers.RandomLocation(),
 
-                    MapContextSource = x => Helpers.GetContextMap($"{mapId}.jpg"),
-                    MapDetailsSource = x => Helpers.GetDetailsMap($"{mapId}.jpg")
+                    MapContextSource = x => Placeholders.Image(400, 300),
+                    MapDetailsSource = x => Placeholders.Image(400, 300)
                 };
             }
         }

QuestPDF.ReportSample/Helpers.cs

@@ -1,6 +1,5 @@
 using System;
 using System.IO;
-using QuestPDF.ReportSample.Layouts;
 using SkiaSharp;
 
 namespace QuestPDF.ReportSample
@@ -10,13 +9,7 @@ namespace QuestPDF.ReportSample
         public static Random Random { get; } = new Random();
         
         public static string GetTestItem(string path) => Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resources", path);
-        
-        public static byte[] GetDocumentMap(string name) => GetImage(Path.Combine("Maps", "Document", name));
-        public static byte[] GetDetailsMap(string name) => GetImage(Path.Combine("Maps", "Details", name));
-        public static byte[] GetContextMap(string name) => GetImage(Path.Combine("Maps", "Context", name));
-        
-        public static byte[] GetPhoto(string name) => GetImage(Path.Combine("Photos", name));
-        
+
         public static byte[] GetImage(string name)
         {
             var photoPath = GetTestItem(name);

QuestPDF.ReportSample/Layouts/Helpers.cs

@@ -1,27 +1,29 @@
 using System;
 using QuestPDF.Fluent;
+using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
 
 namespace QuestPDF.ReportSample.Layouts
 {
     public static class Helpers
     {
-        static IContainer Cell(this IContainer container, string color)
+        static IContainer Cell(this IContainer container, bool background)
         {
             return container
                 .Border(0.5f)
-                .Background(color)
+                .BorderColor(Colors.Grey.Lighten1)
+                .Background(background ? Colors.Grey.Lighten4 : Colors.White)
                 .Padding(5);
         }
         
-        public static IContainer LightCell(this IContainer container)
+        public static IContainer ValueCell(this IContainer container)
         {
-            return container.Cell("#0000");
+            return container.Cell(false);
         }
         
-        public static IContainer DarkCell(this IContainer container)
+        public static IContainer LabelCell(this IContainer container)
         {
-            return container.Cell("#1000");
+            return container.Cell(true);
         }
         
         public static string Format(this Location location)

QuestPDF.ReportSample/Layouts/PhotoTemplate.cs

@@ -1,4 +1,5 @@
 using QuestPDF.Fluent;
+using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
 
 namespace QuestPDF.ReportSample.Layouts
@@ -15,47 +16,45 @@ namespace QuestPDF.ReportSample.Layouts
         public void Compose(IContainer container)
         {
             container
+                .ShowEntire()
                 .Stack(stack =>
                 {
-                    stack.Element(PhotoWithMaps);
-                    stack.Element(PhotoDetails);
+                    stack.Spacing(5);
+                    stack.Item().Element(PhotoWithMaps);
+                    stack.Item().Element(PhotoDetails);
                 });
         }
         
         void PhotoWithMaps(IContainer container)
         {
             container
-                .Padding(-3)
-                .PaddingBottom(3)
                 .Row(row =>
                 {
-                    row.RelativeColumn(2).Padding(3).Component(new ImageTemplate(Model.PhotoData));
+                    row.RelativeColumn(2).AspectRatio(4 / 3f).Image(Placeholders.Image);
 
-                    row.RelativeColumn().Stack(stack =>
+                    row.RelativeColumn().PaddingLeft(5).Stack(stack =>
                     {
-                        stack.Element().Padding(3).Component(new ImageTemplate(Model.MapDetailsSource));
-                        stack.Element().Padding(3).Component(new ImageTemplate(Model.MapContextSource));
+                        stack.Spacing(7f);
+                        
+                        stack.Item().AspectRatio(4 / 3f).Image(Placeholders.Image);
+                        stack.Item().AspectRatio(4 / 3f).Image(Placeholders.Image);
                     });
                 });
         }
 
         void PhotoDetails(IContainer container)
         {
-            container.Stack(stack =>
+            container.Border(0.75f).BorderColor(Colors.Grey.Medium).Grid(grid =>
             {
-                stack.Element().Row(row =>
-                {
-                    row.RelativeColumn().DarkCell().Text("Date", Typography.Normal);
-                    row.RelativeColumn(2).LightCell().Text(Model.Date?.ToString("g") ?? string.Empty, Typography.Normal);
-                    row.RelativeColumn().DarkCell().Text("Location", Typography.Normal);
-                    row.RelativeColumn(2).LightCell().Text(Model.Location.Format(), Typography.Normal);
-                });
+                grid.Columns(6);
                 
-                stack.Element().Row(row =>
-                {
-                    row.RelativeColumn().DarkCell().Text("Comments", Typography.Normal);
-                    row.RelativeColumn(5).LightCell().Text(Model.Comments, Typography.Normal);
-                });
+                grid.Item().LabelCell().Text("Date", Typography.Normal);
+                grid.Item(2).ValueCell().Text(Model.Date?.ToString("g") ?? string.Empty, Typography.Normal);
+                grid.Item().LabelCell().Text("Location", Typography.Normal);
+                grid.Item(2).ValueCell().Text(Model.Location.Format(), Typography.Normal);
+                
+                grid.Item().LabelCell().Text("Comments", Typography.Normal);
+                grid.Item(5).ValueCell().Text(Model.Comments, Typography.Normal);
             });
         }
     }

QuestPDF.ReportSample/Layouts/SectionTemplate.cs

@@ -1,6 +1,5 @@
-using System;
-using System.Linq;
 using QuestPDF.Fluent;
+using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
 
 namespace QuestPDF.ReportSample.Layouts
@@ -17,31 +16,31 @@ namespace QuestPDF.ReportSample.Layouts
         public void Compose(IContainer container)
         {
             container
-                .MinHeight(100)
-                .Section(section =>
+                .EnsureSpace()
+                .Decoration(decoration =>
                 {
-                    section
+                    decoration
                         .Header()
                         .PaddingBottom(5)
                         .Text(Model.Title, Typography.Headline);
 
-                    section.Content().PageableStack(stack =>
+                    decoration.Content().Border(0.75f).BorderColor(Colors.Grey.Medium).Stack(stack =>
                     {
                         foreach (var part in Model.Parts)
                         {
-                            stack.Element().Row(row =>
+                            stack.Item().EnsureSpace(25).Row(row =>
                             {
-                                row.ConstantColumn(150).DarkCell().Text(part.Label, Typography.Normal);
-                                var frame = row.RelativeColumn().LightCell();
+                                row.ConstantColumn(150).LabelCell().Text(part.Label, Typography.Normal);
+                                var frame = row.RelativeColumn().ValueCell();
                             
                                 if (part is ReportSectionText text)
-                                    frame.Text(text.Text, Typography.Normal);
+                                    frame.ShowEntire().Text(text.Text, Typography.Normal);
                         
                                 if (part is ReportSectionMap map)
-                                    frame.Element(container => MapElement(container, map));
+                                    frame.Element(x => MapElement(x, map));
                         
                                 if (part is ReportSectionPhotos photos)
-                                    frame.Element(container => PhotosElement(container, photos));
+                                    frame.Element(x => PhotosElement(x, photos));
                             });
                         }
                     });
@@ -56,12 +55,12 @@ namespace QuestPDF.ReportSample.Layouts
                 return;
             }
 
-            container.Stack(stack =>
+            container.ShowEntire().Stack(stack =>
             {
                 stack.Spacing(5);
                 
-                stack.Element().Component(new ImageTemplate(model.ImageSource));
-                stack.Element().Text(model.Location.Format(), Typography.Normal);
+                stack.Item().MaxWidth(250).AspectRatio(4 / 3f).Image(Placeholders.Image);
+                stack.Item().Text(model.Location.Format(), Typography.Normal);
             });
         }
         
@@ -73,21 +72,12 @@ namespace QuestPDF.ReportSample.Layouts
                 return;
             }
 
-            var rowCount = (int) Math.Ceiling(model.Photos.Count / 3f);
-
-            container.Padding(-2).Stack(stack =>
+            container.Debug("Photos").Grid(grid =>
             {
-                foreach (var rowId in Enumerable.Range(0, rowCount))
-                {
-                    stack.Element().Row(row =>
-                    {
-                        foreach (var id in Enumerable.Range(0, 3))
-                        {
-                            var data = model.Photos.ElementAtOrDefault(rowId + id); 
-                            row.RelativeColumn().Padding(2).Component(new ImageTemplate(data));
-                        }
-                    });
-                }
+                grid.Spacing(5);
+                grid.Columns(3);
+                
+                model.Photos.ForEach(x => grid.Item().AspectRatio(4 / 3f).Image(Placeholders.Image));
             });
         }
     }

QuestPDF.ReportSample/Layouts/StandardReport.cs

@@ -18,79 +18,83 @@ namespace QuestPDF.ReportSample.Layouts
         {
             return new DocumentMetadata()
             {
-                Title = Model.Title,
-                Size = PageSizes.A4
+                Title = Model.Title
             };
         }
 
-        public void Compose(IContainer container)
+        public void Compose(IDocumentContainer container)
         {
             container
-                .PaddingVertical(40)
-                .PaddingHorizontal(50)
-                
                 .Page(page =>
                 {
-                    page.Header(ComposeHeader);
-                    page.Content(ComposeContent);
-                    page.Footer().AlignCenter().PageNumber("Page {number}");
+                    page.MarginVertical(40);
+                    page.MarginHorizontal(50);
+                    
+                    page.Size(PageSizes.A4);
+                        
+                    page.Header().Element(ComposeHeader);
+                    page.Content().Element(ComposeContent);
+                    
+                    page.Footer().AlignCenter().Text(text =>
+                    {
+                        text.DefaultTextStyle(Typography.Normal);
+                        
+                        text.CurrentPageNumber();
+                        text.Span(" / ");
+                        text.TotalPages();
+                    });
                 });
         }
 
         private void ComposeHeader(IContainer container)
         {
-            container.Row(row =>
+            container.Stack(stack =>
             {
-                row.RelativeColumn().MaxWidth(300).Stack(stack =>
+                stack.Item().Row(row =>
                 {
-                    stack.Spacing(5);
+                    row.Spacing(50);
                     
-                    stack
-                        .Element()
-                        .PaddingBottom(5)
-                        .Text(Model.Title, Typography.Title);
-                    
-                    stack.Element().ShowOnce().Stack(table =>
-                    {
-                        table.Spacing(5);
-
-                        foreach (var field in Model.HeaderFields)
-                        {
-                            table.Element().Row(row =>
-                            {
-                                row.ConstantColumn(50)
-                                    .AlignLeft()
-                                    .Text($"{field.Label}:", Typography.Normal);
-                                
-                                row.RelativeColumn()
-                                    .PaddingLeft(10)
-                                    .Text(field.Value, Typography.Normal);
-                            });
-                        }
-                    });
-
+                    row.RelativeColumn().PaddingTop(-10).Text(Model.Title, Typography.Title);
+                    row.ConstantColumn(150).ExternalLink("https://www.questpdf.com").Image(Model.LogoData);
                 });
+
+                stack.Item().ShowOnce().PaddingVertical(15).Border(1f).BorderColor(Colors.Grey.Lighten1).ExtendHorizontal();
                 
-                row.ConstantColumn(150).ExternalLink("https://www.questpdf.com").Image(Model.LogoData);
+                stack.Item().ShowOnce().Grid(grid =>
+                {
+                    grid.Columns(2);
+                    grid.Spacing(5);
+                        
+                    foreach (var field in Model.HeaderFields)
+                    {
+                        grid.Item().Text(text =>
+                        {
+                            text.Span($"{field.Label}: ", Typography.Normal.SemiBold());
+                            text.Span(field.Value, Typography.Normal);
+                        });
+                    }
+                });
             });
         }
 
         void ComposeContent(IContainer container)
         {
-            container.PaddingVertical(20).PageableStack(stack =>
+            container.PaddingVertical(20).Stack(stack =>
             {
                 stack.Spacing(20);
 
-                stack.Element().Component(new TableOfContentsTemplate(Model.Sections));
+                stack.Item().Component(new TableOfContentsTemplate(Model.Sections));
+                
+                stack.Item().PageBreak();
                 
                 foreach (var section in Model.Sections)
-                    stack.Element().Location(section.Title).Component(new SectionTemplate(section));
+                    stack.Item().Location(section.Title).Component(new SectionTemplate(section));
 
-                stack.Element().PageBreak();
-                stack.Element().Location("Photos");
+                stack.Item().PageBreak();
+                stack.Item().Location("Photos");
                 
                 foreach (var photo in Model.Photos)
-                    stack.Element().Component(new PhotoTemplate(photo));
+                    stack.Item().Component(new PhotoTemplate(photo));
             });
         }
     }

QuestPDF.ReportSample/Layouts/TableOfContentsTemplate.cs

@@ -1,6 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
+using System.Collections.Generic;
 using QuestPDF.Fluent;
 using QuestPDF.Infrastructure;
 
@@ -18,21 +16,21 @@ namespace QuestPDF.ReportSample.Layouts
         public void Compose(IContainer container)
         {
             container
-                .Section(section =>
+                .Decoration(decoration =>
                 {
-                    section
+                    decoration
                         .Header()
                         .PaddingBottom(5)
                         .Text("Table of contents", Typography.Headline);
 
-                    section.Content().PageableStack(stack =>
+                    decoration.Content().Stack(stack =>
                     {
                         stack.Spacing(5);
                         
                         for (var i = 0; i < Sections.Count; i++)
-                            stack.Element(c => DrawLink(c, i+1, Sections[i].Title));
+                            stack.Item().Element(c => DrawLink(c, i+1, Sections[i].Title));
 
-                        stack.Element(c => DrawLink(c, Sections.Count+1, "Photos"));
+                        stack.Item().Element(c => DrawLink(c, Sections.Count+1, "Photos"));
                     });
                 });
         }
@@ -45,6 +43,7 @@ namespace QuestPDF.ReportSample.Layouts
                 {
                     row.ConstantColumn(25).Text($"{number}.", Typography.Normal);
                     row.RelativeColumn().Text(locationName, Typography.Normal);
+                    row.ConstantColumn(150).AlignRight().Text(text => text.PageNumberOfLocation(locationName, Typography.Normal));
                 });
         }
     }

QuestPDF.ReportSample/QuestPDF.ReportSample.csproj

@@ -16,11 +16,6 @@
     </ItemGroup>
 
     <ItemGroup>
-      <Folder Include="Resources" />
-    </ItemGroup>
-
-    <ItemGroup>
-        <Content Include="Resources\Photos\readme.txt" />
         <Content Include="Resources\**\**">
             <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
         </Content>
@@ -29,4 +24,8 @@
     <ItemGroup>
       <ProjectReference Include="..\QuestPDF\QuestPDF.csproj" />
     </ItemGroup>
+
+    <ItemGroup>
+      <EmbeddedResource Include="Resources\Logo.png" />
+    </ItemGroup>
 </Project>