Added missing option to style a line

2021.10 Richtext

QuestPDF.Examples/BarCode.cs

@@ -0,0 +1,33 @@
+using System.IO;
+using NUnit.Framework;
+using QuestPDF.Drawing;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples
+{
+    public class BarCode
+    {
+        [Test]
+        public void Example()
+        {
+            FontManager.RegisterFontType("LibreBarcode39", File.OpenRead("LibreBarcode39-Regular.ttf"));
+            
+            RenderingTest
+                .Create()
+                .PageSize(400, 100)
+                .FileName()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Background(Colors.White)
+                        .AlignCenter()
+                        .AlignMiddle()
+                        .Text("*QuestPDF*", TextStyle.Default.FontType("LibreBarcode39").Size(64));
+                });
+        }
+    }
+}

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/ContinousPage.cs

@@ -0,0 +1,46 @@
+using System.Diagnostics;
+using System.Linq;
+using NUnit.Framework;
+using QuestPDF.Drawing;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples
+{
+    public class ContinuousPageDocument : IDocument
+    {
+        public DocumentMetadata GetMetadata() => DocumentMetadata.Default;
+
+        public void Compose(IDocumentContainer container)
+        {
+            container.Page(page =>
+            {
+                page.Margin(20);
+                page.ContinuousSize(150);
+                
+                page.Header().Text("Header");
+                
+                page.Content().PaddingVertical(10).Border(1).Padding(10).Stack(stack =>
+                {
+                    foreach (var index in Enumerable.Range(1, 100))
+                        stack.Item().Text($"Line {index}", TextStyle.Default.Color(Placeholders.Color()));
+                });
+                
+                page.Footer().Text("Footer");
+            });
+        }
+    }
+    
+    public class ContinuousPageExamples
+    {
+        [Test]
+        public void ContinuousPage()
+        {
+            var path = "example.pdf";
+            new ContinuousPageDocument().GeneratePdf(path);
+            Process.Start("explorer", path);
+        }
+    }
+}

QuestPDF.Examples/Engine/ExampleTestBase.cs

@@ -1,95 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using NUnit.Framework;
-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";
-
-            try
-            {
-                var document = new SimpleDocument(container, size);
-                document.GenerateImages(fileNameSchema);
-            }
-            catch (Exception e)
-            {
-                throw new Exception($"Cannot perform test {fileName}", e);
-            }
-
-            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 Drawing.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,
+                RasterDpi = PageSizes.PointsPerInch * ImageScalingFactor,
-                Size = Size
+                DocumentLayoutExceptionThreshold = MaxPages
             };
         }
-
+        
-        public void Compose(IContainer container)
+        public void Compose(IDocumentContainer container)
         {
-            container.Background("#FFF").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,3 +1,4 @@
+using NUnit.Framework;
 using QuestPDF.Examples.Engine;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
@@ -11,33 +12,40 @@ namespace QuestPDF.Examples
         {
             return container
                 .Border(1)
-                .Background(dark ? "#EEE" : "#FFF")
+                .Background(dark ? Colors.Grey.Lighten2 : Colors.White)
                 .Padding(10);
         }
         
-        public static IContainer LabelCell(this IContainer container) => container.Cell(true);
+        public static void LabelCell(this IContainer container, string text) => container.Cell(true).Text(text, TextStyle.Default.Medium());
         public static IContainer ValueCell(this IContainer container) => container.Cell(false);
     }
     
-    public class FrameExample: ExampleTestBase
+    public class FrameExample
     {
-        [ImageSize(550, 400)]
+        [Test]
-        [ShowResult]
+        public void Frame()
-        public void Frame(IContainer container)
         {
-            container
+            RenderingTest
-                .Background("#FFF")
+                .Create()
-                .Padding(25)
+                .PageSize(550, 400)
-                .Stack(stack =>
+                .FileName()
+                .ShowResults()
+                .Render(container =>
                 {
-                    for(var i=1; i<=4; i++)
+                    container
-                    {
+                        .Background("#FFF")
-                        stack.Item().Row(row =>
+                        .Padding(25)
+                        .Stack(stack =>
                         {
-                            row.RelativeColumn(2).LabelCell().Text(Placeholders.Label());
+                            for(var i=1; i<=4; i++)
-                            row.RelativeColumn(3).ValueCell().Text(Placeholders.Paragraph());
+                            {
+                                stack.Item().Row(row =>
+                                {
+                                    row.RelativeColumn(2).LabelCell(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]
+        [Test]
-        [ImageSize(350, 280)]
+        public void LoremPicsum()
-        public void LoremPicsum(IContainer container)
         {
-            container
+            RenderingTest
-                .Background("#FFF")
+                .Create()
-                .Padding(25)
+                .PageSize(350, 280)
-                .Stack(column =>
+                .FileName()
+                .Render(container =>
                 {
-                    column.Spacing(10);
+                    container
+                        .Background("#FFF")
+                        .Padding(25)
+                        .Stack(column =>
+                        {
+                            column.Spacing(10);
 
-                    column
+                            column
-                        .Item()
+                                .Item()
-                        .Component(new LoremPicsum(true));
+                                .Component(new LoremPicsum(true));
                     
-                    column
+                            column
-                        .Item()
+                                .Item()
-                        .AlignRight()
+                                .AlignRight()
-                        .Text("From Lorem Picsum");
+                                .Text("From Lorem Picsum");
+                        });
                 });
         }
     }

QuestPDF.Examples/Padding.cs

@@ -1,132 +1,167 @@
-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
+            RenderingTest
-                .Background("#FDD")
+                .Create()
-                .Padding(50)
+                .PageSize(300, 300)
-
+                .FileName()
-                .Background("#AFA")
+                .ShowResults()
-                .PaddingVertical(50)
+                .Render(container =>
-
-                .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 =>
                 {
-                    column
+                    container
-                        .Item()
+                        .Background("#FDD")
-                        .Height(100)
+                        .Padding(50)
-                        .Background("#FFF")
+
-                        
+                        .Background("#AFA")
-                        .AlignLeft()
+                        .PaddingVertical(50)
-                        .AlignMiddle()
+
+                        .Background("#77F")
+                        .PaddingHorizontal(50)
 
-                        .Width(50)
-                        .Height(50)
                         .Background("#444");
-                    
-                    column
-                        .Item()
-                        .Height(100)
-                        .Background("#DDD")
-                        
-                        .AlignCenter()
-                        .AlignMiddle()
-
-                        .Width(50)
-                        .Height(50)
-                        .Background("#222");
-                    
-                    column
-                        .Item()
-                        .Height(100)
-                        .Background("#BBB")
-                        
-                        .AlignRight()
-                        .AlignMiddle()
-
-                        .Width(50)
-                        .Height(50)
-                        .Background("#000");
                 });
         }
         
-        public void Expand(IContainer container)
+        [Test]
+        public void Border()
         {
-            container
+            RenderingTest
-                .Stack(column =>
+                .Create()
+                .PageSize(200, 150)
+                .FileName()
+                .Render(container =>
                 {
-                    column
+                    container
-                        .Item()
+                        .Background("#EEE")
-                        .Height(150)
+                        .Padding(25)
-                        .Row(row =>
+
+                        .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()
+                            column
-                                .Extend()
+                                .Item()
-                                .Background("FFF")
+                                .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
+                            column
-                        .Item()
+                                .Item()
-                        .Height(150)
+                                .Height(100)
-                        .Row(row =>
+                                .Background("#DDD")
-                        {
+                        
-                            row.RelativeColumn()
+                                .AlignCenter()
-                                .Extend()
+                                .AlignMiddle()
-                                .Background("BBB")
 
-                                .ExtendVertical()
                                 .Width(50)
-                                .Background("444");
+                                .Height(50)
-                            
+                                .Background("#222");
-                            row.RelativeColumn()
+                    
-                                .Extend()
+                            column
-                                .Background("BBB")
+                                .Item()
+                                .Height(100)
+                                .Background("#BBB")
+                        
+                                .AlignRight()
+                                .AlignMiddle()
 
-                                .ExtendVertical()
+                                .Width(50)
-                                .ExtendHorizontal()
+                                .Height(50)
-                                .Background("444");
+                                .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

@@ -6,14 +6,23 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="nunit" Version="3.12.0" />
+        <PackageReference Include="nunit" Version="3.13.2" />
-        <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
+        <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
-        <PackageReference Include="SkiaSharp" Version="2.80.2" />
+        <PackageReference Include="SkiaSharp" Version="2.80.3" />
     </ItemGroup>
 
     <ItemGroup>
       <ProjectReference Include="..\QuestPDF\QuestPDF.csproj" />
     </ItemGroup>
 
+    <ItemGroup>
+      <None Update="quo-vadis.txt">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </None>
+      <None Update="LibreBarcode39-Regular.ttf">
+        <CopyToOutputDirectory>PreserveNewest</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).Underline());
+                        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,277 @@
+using System;
+using System.Linq;
+using System.Text;
+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 SimpleTextBlock()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(500, 300)
+                .FileName()
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(5)
+                        .Box()
+                        .Border(1)
+                        .Padding(10)
+                        .Text(text =>
+                        {
+                            text.DefaultTextStyle(TextStyle.Default.Size(20));
+                            text.Span("This is a normal text, followed by an ");
+                            text.Span("underlined red text.", TextStyle.Default.Size(20).Color(Colors.Red.Medium).Underline());
+                        });
+                });
+        }
+        
+        [Test]
+        public void ParagraphSpacing()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(500, 300)
+                .FileName()
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(5)
+                        .Box()
+                        .Border(1)
+                        .Padding(10)
+                        .Text(text =>
+                        {
+                            text.ParagraphSpacing(10);
+    
+                            foreach (var i in Enumerable.Range(1, 3))
+                            {
+                                text.Span($"Paragraph {i}: ", TextStyle.Default.SemiBold());
+                                text.Line(Placeholders.Paragraph());
+                            }
+                        });
+                });
+        }
+        
+        [Test]
+        public void CustomElement()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(500, 200)
+                .FileName()
+                .ProduceImages()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(5)
+                        .Box()
+                        .Border(1)
+                        .Padding(10)
+                        .Text(text =>
+                        {
+                            text.DefaultTextStyle(TextStyle.Default.Size(20));
+                            text.Span("This is a random image aligned to the baseline: ");
+                            
+                            text.Element()
+                                .PaddingBottom(-6)
+                                .Height(24)
+                                .Width(48)
+                                .Image(Placeholders.Image);
+                            
+                            text.Span(".");
+                        });
+                });
+        }
+        
+        [Test]
+        public void TextElements()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(PageSizes.A4)
+                .FileName()
+                .ProducePdf()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(20)
+                        .Padding(10)
+                        .Box()
+                        .Border(1)
+                        .Padding(5)
+                        .Padding(10)
+                        .Text(text =>
+                        {
+                            text.DefaultTextStyle(TextStyle.Default);
+                            text.AlignLeft();
+                            text.ParagraphSpacing(10);
+
+                            text.Line(Placeholders.LoremIpsum());
+
+                            text.Span($"This is target text that should show up. {DateTime.UtcNow:T} > This is a short sentence that will be wrapped into second line hopefully, right? <", TextStyle.Default.Underline());
+                        });
+                });
+        }
+        
+        [Test]
+        public void TextStack()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(PageSizes.A4)
+                .FileName()
+                .ProducePdf()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(20)
+                        .Padding(10)
+                        .Box()
+                        .Border(1)
+                        .Padding(5)
+                        .Padding(10)
+                        .Text(text =>
+                        {
+                            text.DefaultTextStyle(TextStyle.Default);
+                            text.AlignLeft();
+                            text.ParagraphSpacing(10);
+                            
+                            foreach (var i in Enumerable.Range(1, 100))
+                                text.Line($"{i}: {Placeholders.Paragraph()}");
+                        });
+                });
+        }
+
+        [Test]
+        public void SpaceIssue()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(PageSizes.A4)
+                .FileName()
+                .ProducePdf()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(20)
+                        .Padding(10)
+                        .Box()
+                        .Border(1)
+                        .Padding(5)
+                        .Padding(10)
+                        .Text(text =>
+                        {
+                            text.DefaultTextStyle(TextStyle.Default);
+                            text.AlignLeft();
+                            text.ParagraphSpacing(10);
+
+                            text.Span(Placeholders.LoremIpsum());
+
+                            text.EmptyLine();
+
+                            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).Underline());
+                            text.Span("and this is slightly bigger text.", TextStyle.Default.Size(16));
+
+                            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.Span(".");
+
+                            text.EmptyLine();
+
+                            text.Span("This is page number ");
+                            text.CurrentPageNumber();
+                            text.Span(" out of ");
+                            text.TotalPages();
+
+                            text.EmptyLine();
+
+                            text.ExternalLocation("Please visit QuestPDF website", "https://www.questpdf.com");
+
+                            text.EmptyLine();
+
+                            text.Span(Placeholders.Paragraphs());
+                            
+                            
+                            text.EmptyLine();
+
+                            text.Span(Placeholders.Paragraphs(), TextStyle.Default.Italic());
+                            
+                            text.Line("This is target text that does not show up. " + Placeholders.Paragraph());
+                        });
+                });
+        }
+
+        [Test]
+        public void HugeList()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(PageSizes.A4)
+                .FileName()
+                .ProducePdf()
+                .ShowResults()
+                .Render(container =>
+                {
+                    container
+                        .Padding(20)
+                        .Padding(10)
+                        .Box()
+                        .Border(1)
+                        .Padding(5)
+                        .Padding(10)
+                        .Text(text =>
+                        {
+                            text.DefaultTextStyle(TextStyle.Default);
+                            text.AlignLeft();
+                            text.ParagraphSpacing(10);
+
+                            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).Underline());
+                            text.Span("and this is slightly bigger text.", TextStyle.Default.Size(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.Span(".");
+                            
+                            text.EmptyLine();
+                            
+                            foreach (var i in Enumerable.Range(1, 100))
+                            {
+                                text.Line($"{i}: {Placeholders.Paragraph()}");
+
+                                text.ExternalLocation("Please visit QuestPDF website", "https://www.questpdf.com");
+                                
+                                text.Span("This is page number ");
+                                text.CurrentPageNumber();
+                                text.Span(" out of ");
+                                text.TotalPages();
+                                
+                                text.EmptyLine();
+                            }
+                        });
+                });
+        }
+    }
+}

QuestPDF.ReportSample/DataSource.cs

@@ -18,8 +18,8 @@ namespace QuestPDF.ReportSample
                 HeaderFields = HeaderFields(),
                 
                 LogoData = Helpers.GetImage("Logo.png"),
-                Sections = Enumerable.Range(0, 8).Select(x => GenerateSection()).ToList(),
+                Sections = Enumerable.Range(0, 40).Select(x => GenerateSection()).ToList(),
-                Photos = Enumerable.Range(2, 6).Select(x => GetReportPhotos()).ToList()
+                Photos = Enumerable.Range(0, 25).Select(x => GetReportPhotos()).ToList()
             };
 
             List<ReportHeaderField> HeaderFields()
@@ -52,8 +52,8 @@ namespace QuestPDF.ReportSample
             ReportSection GenerateSection()
             {
                 var sectionLength = Helpers.Random.NextDouble() > 0.75
-                    ? Helpers.Random.Next(10, 20)
+                    ? Helpers.Random.Next(20, 40)
-                    : Helpers.Random.Next(3, 11);
+                    : Helpers.Random.Next(5, 10);
                 
                 return new ReportSection
                 {
@@ -100,8 +100,7 @@ namespace QuestPDF.ReportSample
                 {    
                     Label = "Photos",
                     Photos = Enumerable
-                        .Range(0, Helpers.Random.Next(1, 10))
+                        .Range(0, Helpers.Random.Next(1, 15))
-                        .Select(x => Helpers.Random.Next(0, 128))
                         .Select(x => Placeholders.Image(400, 300))
                         .ToList()
                 };
@@ -111,7 +110,7 @@ namespace QuestPDF.ReportSample
             {
                 return new ReportPhoto()
                 {
-                    PhotoData = Placeholders.Image(400, 300),
+                    PhotoData = Placeholders.Image(800, 600),
 
                     Comments = Placeholders.Sentence(),
                     Date = DateTime.Now - TimeSpan.FromDays(Helpers.Random.NextDouble() * 100),

QuestPDF.ReportSample/Layouts/SectionTemplate.cs

@@ -28,13 +28,13 @@ namespace QuestPDF.ReportSample.Layouts
                     {
                         foreach (var part in Model.Parts)
                         {
-                            stack.Item().Row(row =>
+                            stack.Item().EnsureSpace(25).Row(row =>
                             {
                                 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(x => MapElement(x, map));
@@ -72,7 +72,7 @@ namespace QuestPDF.ReportSample.Layouts
                 return;
             }
 
-            container.Debug("Photo gallery").Grid(grid =>
+            container.Debug("Photos").Grid(grid =>
             {
                 grid.Spacing(5);
                 grid.Columns(3);

QuestPDF.ReportSample/Layouts/StandardReport.cs

@@ -18,21 +18,31 @@ namespace QuestPDF.ReportSample.Layouts
         {
             return new DocumentMetadata()
             {
-                Title = Model.Title,
+                Title = Model.Title
-                Size = PageSizes.A4
             };
         }
 
-        public void Compose(IContainer container)
+        public void Compose(IDocumentContainer container)
         {
             container
-                .PaddingVertical(40)
-                .PaddingHorizontal(50)
                 .Page(page =>
                 {
+                    page.MarginVertical(40);
+                    page.MarginHorizontal(50);
+                    
+                    page.Size(PageSizes.A4);
+                        
                     page.Header().Element(ComposeHeader);
                     page.Content().Element(ComposeContent);
-                    page.Footer().AlignCenter().PageNumber("Page {number}");
+                    
+                    page.Footer().AlignCenter().Text(text =>
+                    {
+                        text.DefaultTextStyle(Typography.Normal);
+                        
+                        text.CurrentPageNumber();
+                        text.Span(" / ");
+                        text.TotalPages();
+                    });
                 });
         }
 
@@ -57,10 +67,10 @@ namespace QuestPDF.ReportSample.Layouts
                         
                     foreach (var field in Model.HeaderFields)
                     {
-                        grid.Item().Stack(row =>
+                        grid.Item().Text(text =>
-                        {   
+                        {
-                            row.Item().AlignLeft().Text(field.Label, Typography.Normal.SemiBold());
+                            text.Span($"{field.Label}: ", Typography.Normal.SemiBold());
-                            row.Item().Text(field.Value, Typography.Normal);
+                            text.Span(field.Value, Typography.Normal);
                         });
                     }
                 });
@@ -75,6 +85,8 @@ namespace QuestPDF.ReportSample.Layouts
 
                 stack.Item().Component(new TableOfContentsTemplate(Model.Sections));
                 
+                stack.Item().PageBreak();
+                
                 foreach (var section in Model.Sections)
                     stack.Item().Location(section.Title).Component(new SectionTemplate(section));
 

QuestPDF.ReportSample/Layouts/TableOfContentsTemplate.cs

@@ -43,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

@@ -8,11 +8,10 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="DeepCloner" Version="0.10.2" />
+        <PackageReference Include="nunit" Version="3.13.2" />
-        <PackageReference Include="nunit" Version="3.12.0" />
+        <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
-        <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
-        <PackageReference Include="SkiaSharp" Version="2.80.2" />
+        <PackageReference Include="SkiaSharp" Version="2.80.3" />
     </ItemGroup>
 
     <ItemGroup>

QuestPDF.ReportSample/Tests.cs

@@ -25,9 +25,11 @@ namespace QuestPDF.ReportSample
         [Test] 
         public void PerformanceBenchmark()
         {
+            // target document length should be around 100 pages
+            
             // test size
-            const int testSize = 100;
+            const int testSize = 10;
-            const decimal performanceTarget = 5; // documents per second
+            const decimal performanceTarget = 1; // documents per second
 
             // create report models
             var reports = Enumerable
@@ -55,8 +57,8 @@ namespace QuestPDF.ReportSample
             Console.WriteLine($"Time per document: {performance:N} ms");
             Console.WriteLine($"Documents per second: {speed:N} d/s");
 
-            if (speed < performanceTarget)
+            //if (speed < performanceTarget)
-                throw new Exception("Rendering algorithm is too slow.");
+            //    throw new Exception("Rendering algorithm is too slow.");
         }
     }
 }

QuestPDF.ReportSample/Typography.cs

@@ -8,6 +8,6 @@ namespace QuestPDF.ReportSample
     {
         public static TextStyle Title => TextStyle.Default.FontType(Fonts.Calibri).Color(Colors.Blue.Darken3).Size(26).Black();
         public static TextStyle Headline => TextStyle.Default.FontType(Fonts.Calibri).Color(Colors.Blue.Medium).Size(16).SemiBold();
-        public static TextStyle Normal => TextStyle.Default.FontType(Fonts.Calibri).Color(Colors.Black).Size(11).LineHeight(1.25f).AlignLeft();
+        public static TextStyle Normal => TextStyle.Default.FontType(Fonts.Calibri).Color(Colors.Black).Size(11).LineHeight(1.1f);
     }
 }

QuestPDF.UnitTests/AlignmentTests.cs

@@ -10,11 +10,7 @@ namespace QuestPDF.UnitTests
     public class AlignmentTests
     {
         [Test]
-        public void Measure_ShouldHandleNullChild() => new Alignment().MeasureWithoutChild();
+        public void Measure() => SimpleContainerTests.Measure<Alignment>();
-        
-        [Test]
-        public void Draw_ShouldHandleNullChild() => new Alignment().DrawWithoutChild();
-
         [Test]
         public void Draw_HorizontalCenter_VerticalCenter()
         {

QuestPDF.UnitTests/AspectRatioTests.cs

@@ -9,12 +9,6 @@ namespace QuestPDF.UnitTests
     [TestFixture]
     public class AspectRatioTests
     {
-        [Test]
-        public void Measure_ShouldHandleNullChild() => new AspectRatio().MeasureWithoutChild();
-        
-        [Test]
-        public void Draw_ShouldHandleNullChild() => new AspectRatio().DrawWithoutChild();
-        
         [Test]
         public void Measure_FitWidth_EnoughSpace_FullRender()
         {

QuestPDF.UnitTests/BackgroundTests.cs

@@ -10,8 +10,8 @@ namespace QuestPDF.UnitTests
     public class BackgroundTests
     {
         [Test]
-        public void Measure_ShouldHandleNullChild() => new Background().MeasureWithoutChild();
+        public void Measure() => SimpleContainerTests.Measure<Background>();
-
+        
         [Test]
         public void Draw_ShouldHandleNullChild()
         {

QuestPDF.UnitTests/BorderTests.cs

@@ -11,8 +11,8 @@ namespace QuestPDF.UnitTests
     public class BorderTests
     {
         [Test]
-        public void Measure_ShouldHandleNullChild() => new Border().MeasureWithoutChild();
+        public void Measure() => SimpleContainerTests.Measure<Border>();
-
+        
         [Test]
         public void ComponentShouldNotAffectLayout()
         {

QuestPDF.UnitTests/BoxTests.cs

@@ -0,0 +1,56 @@
+using NUnit.Framework;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+using QuestPDF.UnitTests.TestEngine;
+
+namespace QuestPDF.UnitTests
+{
+    [TestFixture]
+    public class BoxTests
+    {
+        [Test]
+        public void Measure() => SimpleContainerTests.Measure<Box>();
+        
+        [Test]
+        public void Draw_Wrap()
+        {
+            TestPlan
+                .For(x => new Box
+                {
+                    Child = x.CreateChild()
+                })
+                .DrawElement(new Size(400, 300))
+                .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: new Wrap())
+                .CheckDrawResult();
+        }
+        
+        [Test]
+        public void Measure_PartialRender()
+        {
+            TestPlan
+                .For(x => new Box
+                {
+                    Child = x.CreateChild()
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: new PartialRender(200, 100))
+                .ExpectChildDraw(new Size(200, 100))
+                .CheckDrawResult();
+        }
+        
+        [Test]
+        public void Measure_FullRender()
+        {
+            TestPlan
+                .For(x => new Box
+                {
+                    Child = x.CreateChild()
+                })
+                .MeasureElement(new Size(500, 400))
+                .ExpectChildMeasure(expectedInput: new Size(500, 400), returns: new FullRender(300, 200))
+                .ExpectChildDraw(new Size(300, 200))
+                .CheckDrawResult();
+        }
+    }
+}

QuestPDF.UnitTests/ConstrainedTests.cs

@@ -9,12 +9,6 @@ namespace QuestPDF.UnitTests
     [TestFixture]
     public class ConstrainedTests
     {
-        [Test]
-        public void Measure_ShouldHandleNullChild() => new Constrained().MeasureWithoutChild();
-        
-        [Test]
-        public void Draw_ShouldHandleNullChild() => new Constrained().DrawWithoutChild();
-
         [Test]
         public void Measure_MinHeight_ExpectWrap()
         {

QuestPDF.UnitTests/DebugTests.cs

@@ -1,10 +0,0 @@
-using NUnit.Framework;
-
-namespace QuestPDF.UnitTests
-{
-    [TestFixture]
-    public class DebugTests
-    {
-        
-    }
-}

QuestPDF.UnitTests/EnsureSpaceTests.cs

@@ -78,5 +78,8 @@ namespace QuestPDF.UnitTests
                 .ExpectChildMeasure(new Size(400, 300), new FullRender(300, 250))
                 .CheckMeasureResult(new FullRender(300, 250));
         }
+        
+        [Test]
+        public void Draw() => SimpleContainerTests.Draw<EnsureSpace>();
     }
 }

QuestPDF.UnitTests/ExtendTests.cs

@@ -9,12 +9,6 @@ namespace QuestPDF.UnitTests
     [TestFixture]
     public class ExtendTests
     {
-        [Test]
-        public void Measure_ShouldHandleNullChild() => new Extend().MeasureWithoutChild();
-        
-        [Test]
-        public void Draw_ShouldHandleNullChild() => new Extend().DrawWithoutChild();
-        
         [Test]
         public void Measure_ReturnsWrap_WhenChildReturnsWrap()
         {
@@ -87,5 +81,8 @@ namespace QuestPDF.UnitTests
                 .ExpectChildMeasure(new Size(400, 200), new FullRender(100, 100))
                 .CheckMeasureResult(new FullRender(100, 200));
         }
+
+        [Test]
+        public void Draw() => SimpleContainerTests.Draw<Extend>();
     }
 }

QuestPDF.UnitTests/ExternalLinkTests.cs

@@ -0,0 +1,15 @@
+using NUnit.Framework;
+using QuestPDF.Elements;
+using QuestPDF.UnitTests.TestEngine;
+
+namespace QuestPDF.UnitTests
+{
+    [TestFixture]
+    public class ExternalLinkTests
+    {
+        [Test]
+        public void Measure() => SimpleContainerTests.Measure<ExternalLink>();
+        
+        // TODO: consider tests for the Draw method
+    }
+}

QuestPDF.UnitTests/GridTests.cs

@@ -6,7 +6,7 @@ using QuestPDF.UnitTests.TestEngine;
 
 namespace QuestPDF.UnitTests
 {
-    /*[TestFixture]
+    [TestFixture]
     public class GridTests
     {
         #region Alignment
@@ -45,24 +45,24 @@ namespace QuestPDF.UnitTests
                 {
                     row.RelativeColumn(6).Element(childA);
                     row.RelativeColumn(4).Element(childB);
-                    row.RelativeColumn(2).Element(Empty.Instance);
+                    row.RelativeColumn(2);
                 });
                 
                 stack.Item().Row(row =>
                 {
                     row.RelativeColumn(4).Element(childC);
                     row.RelativeColumn(2).Element(childD);
-                    row.RelativeColumn(6).Element(Empty.Instance);
+                    row.RelativeColumn(6);
                 });
                 
                 stack.Item().Row(row =>
                 {
                     row.RelativeColumn(8).Element(childE);
-                    row.RelativeColumn(4).Element(Empty.Instance);
+                    row.RelativeColumn(4);
                 });
             });
             
-            structure.Child.Should().BeEquivalentTo(expected, o => o.WithStrictOrdering().IncludingAllRuntimeProperties());
+            TestPlan.CompareOperations(structure, expected);
         }
         
         [Test]
@@ -97,29 +97,29 @@ namespace QuestPDF.UnitTests
             {
                 stack.Item().Row(row =>
                 {
-                    row.RelativeColumn(1).Element(Empty.Instance);
+                    row.RelativeColumn(1);
                     row.RelativeColumn(6).Element(childA);
                     row.RelativeColumn(4).Element(childB);
-                    row.RelativeColumn(1).Element(Empty.Instance);
+                    row.RelativeColumn(1);
                 });
                 
                 stack.Item().Row(row =>
                 {
-                    row.RelativeColumn(3).Element(Empty.Instance);
+                    row.RelativeColumn(3);
                     row.RelativeColumn(4).Element(childC);
                     row.RelativeColumn(2).Element(childD);
-                    row.RelativeColumn(3).Element(Empty.Instance);
+                    row.RelativeColumn(3);
                 });
                 
                 stack.Item().Row(row =>
                 {
-                    row.RelativeColumn(2).Element(Empty.Instance);
+                    row.RelativeColumn(2);
                     row.RelativeColumn(8).Element(childE);
-                    row.RelativeColumn(2).Element(Empty.Instance);
+                    row.RelativeColumn(2);
                 });
             });
 
-            structure.Child.Should().BeEquivalentTo(expected, o => o.WithStrictOrdering().IncludingAllRuntimeProperties());
+            TestPlan.CompareOperations(structure, expected);
         }
         
         [Test]
@@ -150,32 +150,102 @@ namespace QuestPDF.UnitTests
             // assert
             var expected = new Container();
             
-            expected.Container().Stack(stack =>
+            expected.Stack(stack =>
             {
                 stack.Item().Row(row =>
                 {
-                    row.RelativeColumn(2).Element(Empty.Instance);
+                    row.RelativeColumn(2);
                     row.RelativeColumn(6).Element(childA);
                     row.RelativeColumn(4).Element(childB);
                 });
                 
                 stack.Item().Row(row =>
                 {
-                    row.RelativeColumn(6).Element(Empty.Instance);
+                    row.RelativeColumn(6);
                     row.RelativeColumn(4).Element(childC);
                     row.RelativeColumn(2).Element(childD);
                 });
                 
                 stack.Item().Row(row =>
                 {
-                    row.RelativeColumn(4).Element(Empty.Instance);
+                    row.RelativeColumn(4);
                     row.RelativeColumn(8).Element(childE);
                 });
             });
             
-            structure.Child.Should().BeEquivalentTo(expected, o => o.WithStrictOrdering().IncludingAllRuntimeProperties());
+            TestPlan.CompareOperations(structure, expected);
         }
         
         #endregion
-    }*/
+        
+        #region Spacing
+        
+        [Test]
+        public void Spacing()
+        {
+            // arrange
+            var structure = new Container();
+
+            var childA = TestPlan.CreateUniqueElement();
+            var childB = TestPlan.CreateUniqueElement();
+            var childC = TestPlan.CreateUniqueElement();
+            var childD = TestPlan.CreateUniqueElement();
+
+            // act
+            structure
+                .Grid(grid =>
+                {
+                    grid.Columns(16);
+                    grid.AlignCenter();
+                    
+                    grid.VerticalSpacing(20);
+                    grid.HorizontalSpacing(30);
+
+                    grid.Item(5).Element(childA);
+                    grid.Item(5).Element(childB);
+                    grid.Item(10).Element(childC);
+                    grid.Item(12).Element(childD);
+                });
+            
+            // assert
+            var expected = new Container();
+            
+            expected.Stack(stack =>
+            {
+                stack.Spacing(20);
+                
+                stack.Item().Row(row =>
+                {
+                    row.Spacing(30);
+                    
+                    row.RelativeColumn(3);
+                    row.RelativeColumn(5).Element(childA);
+                    row.RelativeColumn(5).Element(childB);
+                    row.RelativeColumn(3);
+                });
+                
+                stack.Item().Row(row =>
+                {
+                    row.Spacing(30);
+                    
+                    row.RelativeColumn(3);
+                    row.RelativeColumn(10).Element(childC);
+                    row.RelativeColumn(3);
+                });
+                
+                stack.Item().Row(row =>
+                {
+                    row.Spacing(30);
+                    
+                    row.RelativeColumn(2);
+                    row.RelativeColumn(12).Element(childD);
+                    row.RelativeColumn(2);
+                });
+            });
+            
+            TestPlan.CompareOperations(structure, expected);
+        }
+        
+        #endregion
+    }
 }

QuestPDF.UnitTests/Helpers.cs

@@ -1,30 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using FluentAssertions;
-using QuestPDF.Infrastructure;
-using QuestPDF.UnitTests.TestEngine;
-
-namespace QuestPDF.UnitTests
-{
-    public static class Helpers
-    {
-        public static Random Random = new Random();
-        
-        public static Size RandomSize => new Size(Random.Next(200, 400), Random.Next(100, 200));
-
-        public static void ShouldEqual(this IEnumerable<OperationBase> commands, IEnumerable<OperationBase> expected)
-        {
-            commands.Should().HaveSameCount(expected);
-            
-            commands
-                .Zip(expected)
-                .ToList()
-                .ForEach(x =>
-                {
-                    x.First.Should().BeOfType(x.Second.GetType());
-                    x.First.Should().BeEquivalentTo(x.Second, y => y.RespectingRuntimeTypes());
-                });
-        }
-    }
-}

QuestPDF.UnitTests/ImageTests.cs

@@ -11,12 +11,6 @@ namespace QuestPDF.UnitTests
     [TestFixture]
     public class ImageTests
     {
-        [Test]
-        public void Measure_ShouldHandleNullChild() => new AspectRatio().MeasureWithoutChild();
-        
-        [Test]
-        public void Draw_ShouldHandleNullChild() => new AspectRatio().DrawWithoutChild();
-        
         [Test]
         public void Measure_TakesAvailableSpaceRegardlessOfSize()
         {

QuestPDF.UnitTests/InternalLinkTests.cs

@@ -0,0 +1,15 @@
+using NUnit.Framework;
+using QuestPDF.Elements;
+using QuestPDF.UnitTests.TestEngine;
+
+namespace QuestPDF.UnitTests
+{
+    [TestFixture]
+    public class InternalLinkTests
+    {
+        [Test]
+        public void Measure() => SimpleContainerTests.Measure<InternalLink>();
+        
+        // TODO: consider tests for the Draw method
+    }
+}

QuestPDF.UnitTests/InternalLocationTests.cs

@@ -0,0 +1,15 @@
+using NUnit.Framework;
+using QuestPDF.Elements;
+using QuestPDF.UnitTests.TestEngine;
+
+namespace QuestPDF.UnitTests
+{
+    [TestFixture]
+    public class InternalLocationTests
+    {
+        [Test]
+        public void Measure() => SimpleContainerTests.Measure<InternalLink>();
+        
+        // TODO: consider tests for the Draw method
+    }
+}

QuestPDF.UnitTests/LayersTests.cs

@@ -0,0 +1,131 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+using QuestPDF.UnitTests.TestEngine;
+
+namespace QuestPDF.UnitTests
+{
+    [TestFixture]
+    public class LayersTests
+    {
+        private const string BackgroundLayer = "background";
+        private const string MainLayer = "main";
+        private const string ForegroundLayer = "foreground";
+        
+        private static Layers GetLayers(TestPlan x)
+        {
+            return new Layers
+            {
+                Children = new List<Layer>
+                {
+                    new Layer
+                    {
+                        Child = x.CreateChild(BackgroundLayer)
+                    },
+                    new Layer
+                    {
+                        Child = x.CreateChild(MainLayer),
+                        IsPrimary = true
+                    },
+                    new Layer
+                    {
+                        Child = x.CreateChild(ForegroundLayer)
+                    }
+                }
+            };
+        }
+        
+        #region measure
+        
+        [Test]
+        public void Measure_Wrap()
+        {
+            TestPlan
+                .For(GetLayers)
+                .MeasureElement(new Size(800, 600))
+                .ExpectChildMeasure(MainLayer, new Size(800, 600), new Wrap())
+                .CheckMeasureResult(new Wrap());
+        }
+
+        [Test]
+        public void Measure_PartialRender()
+        {
+            TestPlan
+                .For(GetLayers)
+                .MeasureElement(new Size(800, 600))
+                .ExpectChildMeasure(MainLayer, new Size(800, 600), new PartialRender(700, 500))
+                .CheckMeasureResult(new PartialRender(700, 500));
+        }
+        
+        [Test]
+        public void Measure_FullRender()
+        {
+            TestPlan
+                .For(GetLayers)
+                .MeasureElement(new Size(800, 600))
+                .ExpectChildMeasure(MainLayer, new Size(800, 600), new FullRender(500, 400))
+                .CheckMeasureResult(new FullRender(500, 400));
+        }
+        
+        #endregion
+        
+        #region draw
+        
+        [Test]
+        public void Draw_Simple()
+        {
+            TestPlan
+                .For(GetLayers)
+                .MeasureElement(new Size(800, 600))
+                
+                .ExpectChildMeasure(BackgroundLayer, new Size(800, 600), new FullRender(100, 200))
+                .ExpectChildMeasure(MainLayer, new Size(800, 600), new PartialRender(200, 300))
+                .ExpectChildMeasure(ForegroundLayer, new Size(800, 600), new FullRender(300, 400))
+                
+                
+                .ExpectChildDraw(BackgroundLayer, new Size(800, 600))
+                .ExpectChildDraw(MainLayer, new Size(800, 600))
+                .ExpectChildDraw(ForegroundLayer, new Size(800, 600))
+                
+                .CheckDrawResult();
+        }
+        
+        [Test]
+        public void Draw_WhenSecondaryLayerReturnsWrap_SkipThatLayer_1()
+        {
+            TestPlan
+                .For(GetLayers)
+                .MeasureElement(new Size(800, 600))
+                
+                .ExpectChildMeasure(BackgroundLayer, new Size(800, 600), new PartialRender(100, 200))
+                .ExpectChildMeasure(MainLayer, new Size(800, 600), new PartialRender(200, 300))
+                .ExpectChildMeasure(ForegroundLayer, new Size(800, 600), new Wrap())
+                
+                .ExpectChildDraw(BackgroundLayer, new Size(800, 600))
+                .ExpectChildDraw(MainLayer, new Size(800, 600))
+                
+                .CheckDrawResult();
+        }
+        
+        [Test]
+        public void Draw_WhenSecondaryLayerReturnsWrap_SkipThatLayer_2()
+        {
+            TestPlan
+                .For(GetLayers)
+                .MeasureElement(new Size(800, 600))
+                
+                .ExpectChildMeasure(BackgroundLayer, new Size(800, 600), new Wrap())
+                .ExpectChildMeasure(MainLayer, new Size(800, 600), new PartialRender(200, 300))
+                .ExpectChildMeasure(ForegroundLayer, new Size(800, 600), new PartialRender(300, 400))
+                
+                .ExpectChildDraw(MainLayer, new Size(800, 600))
+                .ExpectChildDraw(ForegroundLayer, new Size(800, 600))
+                
+                .CheckDrawResult();
+        }
+        
+        #endregion
+    }
+}

QuestPDF.UnitTests/PaddingTests.cs

@@ -9,12 +9,6 @@ namespace QuestPDF.UnitTests
     [TestFixture]
     public class PaddingTests
     {
-        [Test]
-        public void Measure_ShouldHandleNullChild() => new Padding().MeasureWithoutChild();
-        
-        [Test]
-        public void Draw_ShouldHandleNullChild() => new Padding().DrawWithoutChild();
-        
         private Padding GetPadding(TestPlan plan)
         {
             return new Padding()

QuestPDF.UnitTests/PageBreakTests.cs

@@ -16,7 +16,7 @@ namespace QuestPDF.UnitTests
                 .For(x => new PageBreak())
                 
                 .MeasureElement(new Size(400, 300))
-                .CheckMeasureResult(new PartialRender(400, 300))
+                .CheckMeasureResult(new PartialRender(Size.Zero))
                 
                 .DrawElement(new Size(400, 300))
                 .CheckDrawResult()

QuestPDF.UnitTests/PageNumberTests.cs

@@ -1,10 +0,0 @@
-using NUnit.Framework;
-
-namespace QuestPDF.UnitTests
-{
-    [TestFixture]
-    public class PageNumberTests
-    {
-
-    }
-}

QuestPDF.UnitTests/QuestPDF.UnitTests.csproj

@@ -6,12 +6,11 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="FluentAssertions" Version="5.10.3" />
+        <PackageReference Include="FluentAssertions" Version="6.1.0" />
-        <PackageReference Include="Moq" Version="4.13.1" />
+        <PackageReference Include="nunit" Version="3.13.2" />
-        <PackageReference Include="nunit" Version="3.13.1" />
+        <PackageReference Include="NUnit3TestAdapter" Version="4.0.0" />
-        <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.0" />
-        <PackageReference Include="SkiaSharp" Version="2.80.2" />
+        <PackageReference Include="SkiaSharp" Version="2.80.3" />
     </ItemGroup>
 
     <ItemGroup>

QuestPDF.UnitTests/RotateTests.cs

@@ -0,0 +1,31 @@
+using NUnit.Framework;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+using QuestPDF.UnitTests.TestEngine;
+
+namespace QuestPDF.UnitTests
+{
+    [TestFixture]
+    public class RotateTests
+    {
+        [Test]
+        public void Measure() => SimpleContainerTests.Measure<Rotate>();
+
+        [Test]
+        public void Draw()
+        {
+            TestPlan
+                .For(x => new Rotate
+                {
+                    Child = x.CreateChild(),
+                    Angle = 123
+                })
+                .DrawElement(new Size(400, 300))
+                .ExpectCanvasRotate(123)
+                .ExpectChildDraw(new Size(400, 300))
+                .ExpectCanvasRotate(-123)
+                .CheckDrawResult();
+        } 
+    }
+}

QuestPDF.UnitTests/RowTests.cs

@@ -1,6 +1,7 @@
 using NUnit.Framework;
 using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
+using QuestPDF.Fluent;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
 
@@ -109,8 +110,158 @@ namespace QuestPDF.UnitTests
 
         #endregion
         
-        // TODO: add tests for the spacing property
+        #region Structure
-        // TODO: add tests for the tree builder method
+        
-        // TODO: add tests for relative column
+        [Test]
+        public void Structure_RelativeColumnsHandling()
+        { 
+            // arrange
+            var childA = TestPlan.CreateUniqueElement();
+            var childB = TestPlan.CreateUniqueElement();
+            var childC = TestPlan.CreateUniqueElement();
+            var childD = TestPlan.CreateUniqueElement();
+            var childE = TestPlan.CreateUniqueElement();
+
+            const int spacing = 25;
+            var availableSpace = new Size(1100, 400);
+            
+            // act
+            var value = new Container();
+
+            value.Row(row =>
+            {
+                row.Spacing(spacing);
+                
+                row.ConstantColumn(150).Element(childA);
+                row.ConstantColumn(250).Element(childB);
+                row.RelativeColumn(1).Element(childC);
+                row.RelativeColumn(2).Element(childD);
+                row.RelativeColumn(3).Element(childE);
+            });
+            
+            // assert
+            var expected = new Container();
+
+            expected.Row(row =>
+            {
+                row.Spacing(spacing);
+                
+                row.ConstantColumn(150).Element(childA);
+                row.ConstantColumn(250).Element(childB);
+                row.ConstantColumn(100).Element(childC);
+                row.ConstantColumn(200).Element(childD);
+                row.ConstantColumn(300).Element(childE);
+            });
+            
+            TestPlan.CompareOperations(value, expected, availableSpace);
+        }
+        
+        [Test]
+        public void Structure_Tree()
+        { 
+            // arrange
+            var childA = TestPlan.CreateUniqueElement();
+            var childB = TestPlan.CreateUniqueElement();
+            var childC = TestPlan.CreateUniqueElement();
+            var childD = TestPlan.CreateUniqueElement();
+            var childE = TestPlan.CreateUniqueElement();
+
+            const int spacing = 25;
+            var availableSpace = new Size(1200, 400);
+            
+            // act
+            var value = new Container();
+
+            value.Row(row =>
+            {
+                row.Spacing(spacing);
+                
+                row.ConstantColumn(150).Element(childA);
+                row.ConstantColumn(200).Element(childB);
+                row.ConstantColumn(250).Element(childC);
+                row.RelativeColumn(2).Element(childD);
+                row.RelativeColumn(3).Element(childE);
+            });
+            
+            // assert
+            var expected = new SimpleRow
+            {
+                Left = new SimpleRow
+                {
+                    Left = new SimpleRow
+                    {
+                        Left = new Constrained
+                        {
+                            MinWidth = 150,
+                            MaxWidth = 150,
+                            Child = childA
+                        },
+                        Right = new Constrained
+                        {
+                            MinWidth = 25,
+                            MaxWidth = 25
+                        }
+                    },
+                    Right = new SimpleRow
+                    {
+                        Left = new Constrained
+                        {
+                            MinWidth = 200,
+                            MaxWidth = 200,
+                            Child = childB
+                        },
+                        Right = new Constrained
+                        {
+                            MinWidth = 25,
+                            MaxWidth = 25
+                        }
+                    }
+                },
+                Right = new SimpleRow
+                {
+                    Left = new SimpleRow
+                    {
+                        Left = new Constrained
+                        {
+                            MinWidth = 250,
+                            MaxWidth = 250,
+                            Child = childC
+                        },
+                        Right = new Constrained
+                        {
+                            MinWidth = 25,
+                            MaxWidth = 25
+                        }
+                    },
+                    Right = new SimpleRow
+                    {
+                        Left = new Constrained
+                        {
+                            MinWidth = 200,
+                            MaxWidth = 200,
+                            Child = childD
+                        },
+                        Right = new SimpleRow
+                        {
+                            Left = new Constrained
+                            {
+                                MinWidth = 25,
+                                MaxWidth = 25
+                            },
+                            Right = new Constrained
+                            {
+                                MinWidth = 300,
+                                MaxWidth = 300,
+                                Child = childE
+                            }
+                        }
+                    }
+                }
+            };
+            
+            TestPlan.CompareOperations(value, expected, availableSpace);
+        }
+        
+        #endregion
     }
 }

QuestPDF.UnitTests/ScaleTests.cs

@@ -0,0 +1,152 @@
+using NUnit.Framework;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+using QuestPDF.UnitTests.TestEngine;
+
+namespace QuestPDF.UnitTests
+{
+    [TestFixture]
+    public class ScaleTests
+    {
+        #region measure
+        
+        [Test]
+        public void Measure_Wrap()
+        {
+            TestPlan
+                .For(x => new Scale
+                {
+                    Child = x.CreateChild(),
+                    ScaleX = 3,
+                    ScaleY = 2
+                })
+                .MeasureElement(new Size(900, 800))
+                .ExpectChildMeasure(new Size(300, 400), new Wrap())
+                .CheckMeasureResult(new Wrap());
+        }
+        
+        [Test]
+        public void Measure_PartialRender()
+        {
+            TestPlan
+                .For(x => new Scale
+                {
+                    Child = x.CreateChild(),
+                    ScaleX = 3,
+                    ScaleY = 2
+                })
+                .MeasureElement(new Size(900, 800))
+                .ExpectChildMeasure(new Size(300, 400), new PartialRender(200, 350))
+                .CheckMeasureResult(new PartialRender(600, 700));
+        }
+        
+        [Test]
+        public void Measure_FullRender()
+        {
+            TestPlan
+                .For(x => new Scale
+                {
+                    Child = x.CreateChild(),
+                    ScaleX = 3,
+                    ScaleY = 2
+                })
+                .MeasureElement(new Size(900, 800))
+                .ExpectChildMeasure(new Size(300, 400), new FullRender(250, 300))
+                .CheckMeasureResult(new FullRender(750, 600));
+        }
+        
+        [Test]
+        public void Measure_NegativeScaleX()
+        {
+            TestPlan
+                .For(x => new Scale
+                {
+                    Child = x.CreateChild(),
+                    ScaleX = -2,
+                    ScaleY = 1
+                })
+                .MeasureElement(new Size(800, 600))
+                .ExpectChildMeasure(new Size(400, 600), new FullRender(300, 500))
+                .CheckMeasureResult(new FullRender(600, 500));
+        }
+        
+        [Test]
+        public void Measure_NegativeScaleY()
+        {
+            TestPlan
+                .For(x => new Scale
+                {
+                    Child = x.CreateChild(),
+                    ScaleX = 1,
+                    ScaleY = -3
+                })
+                .MeasureElement(new Size(800, 600))
+                .ExpectChildMeasure(new Size(800, 200), new FullRender(800, 100))
+                .CheckMeasureResult(new FullRender(800, 300));
+        }
+        
+        #endregion
+        
+        #region draw
+        
+        [Test]
+        public void Draw_Simple()
+        {
+            TestPlan
+                .For(x => new Scale
+                {
+                    Child = x.CreateChild(),
+                    ScaleX = 3,
+                    ScaleY = 2
+                })
+                .DrawElement(new Size(900, 800))
+                .ExpectCanvasTranslate(0, 0)
+                .ExpectCanvasScale(3, 2)
+                .ExpectChildDraw(new Size(300, 400))
+                .ExpectCanvasScale(1/3f, 1/2f)
+                .ExpectCanvasTranslate(0, 0)
+                .CheckDrawResult();
+        }
+        
+        [Test]
+        public void Draw_NegativeScaleX()
+        {
+            TestPlan
+                .For(x => new Scale
+                {
+                    Child = x.CreateChild(),
+                    ScaleX = -3,
+                    ScaleY = 2
+                })
+                .DrawElement(new Size(900, 800))
+                .ExpectCanvasTranslate(900, 0)
+                .ExpectCanvasScale(-3, 2)
+                .ExpectChildDraw(new Size(300, 400))
+                .ExpectCanvasScale(-1/3f, 1/2f)
+                .ExpectCanvasTranslate(-900, 0)
+                .CheckDrawResult();
+        }
+        
+        [Test]
+        public void Draw_NegativeScaleY()
+        {
+            TestPlan
+                .For(x => new Scale
+                {
+                    Child = x.CreateChild(),
+                    ScaleX = 3,
+                    ScaleY = -2
+                })
+                .DrawElement(new Size(900, 800))
+                .ExpectCanvasTranslate(0, 800)
+                .ExpectCanvasScale(3, -2)
+                .ExpectChildDraw(new Size(300, 400))
+                .ExpectCanvasScale(1/3f, -1/2f)
+                .ExpectCanvasTranslate(0, -800)
+                .CheckDrawResult();
+        }
+        
+        #endregion
+    }
+}

QuestPDF.UnitTests/ShowEntireTests.cs

@@ -47,5 +47,8 @@ namespace QuestPDF.UnitTests
                 .ExpectChildMeasure(new Size(400, 300), new FullRender(300, 200))
                 .CheckMeasureResult(new FullRender(300, 200));
         }
+        
+        [Test]
+        public void Draw() => SimpleContainerTests.Draw<ShowEntire>();
     }
 }

QuestPDF.UnitTests/ShowOnceTest.cs

@@ -1,5 +1,4 @@
-using Moq;
+using NUnit.Framework;
-using NUnit.Framework;
 using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
@@ -11,33 +10,7 @@ namespace QuestPDF.UnitTests
     public class ShowOnceTest
     {
         [Test]
-        public void Measure_ShouldHandleNullChild() => new ShowOnce().MeasureWithoutChild();
+        public void Draw()
-        
-        [Test]
-        public void Draw_ShouldHandleNullChild() => new ShowOnce().DrawWithoutChild();
-
-        [Test]
-        public void ShouldRenderOnce_WhenRenderingCalledMultipleTimes()
-        {
-            var child = new Mock<Element>();
-            
-            child
-                .Setup(x => x.Measure(It.IsAny<Size>()))
-                .Returns(() => new FullRender(Size.Zero));
-
-            var element = new ShowOnce()
-            {
-                Child = child.Object
-            };
-
-            element.Draw(null, Size.Zero);
-            element.Draw(null, Size.Zero);
-            
-            child.Verify(x => x.Draw(It.IsAny<ICanvas>(), It.IsAny<Size>()), Times.Once);
-        }
-        
-        [Test]
-        public void Draw_HorizontalRight_VerticalTop()
         {
             TestPlan
                 .For(x => new ShowOnce()

QuestPDF.UnitTests/SimpleRotateTests.cs

@@ -0,0 +1,162 @@
+using NUnit.Framework;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+using QuestPDF.UnitTests.TestEngine;
+
+namespace QuestPDF.UnitTests
+{
+    [TestFixture]
+    public class SimpleRotateTests
+    {
+        #region measure
+        
+        [Test]
+        public void Measure_Wrap()
+        {
+            TestPlan
+                .For(x => new SimpleRotate
+                {
+                    Child = x.CreateChild(),
+                    TurnCount = 0
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure(new Size(400, 300), new Wrap())
+                .CheckMeasureResult(new Wrap());
+        }
+        
+        [Test]
+        public void Measure_PartialRender()
+        {
+            TestPlan
+                .For(x => new SimpleRotate
+                {
+                    Child = x.CreateChild(),
+                    TurnCount = 0
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure(new Size(400, 300), new PartialRender(300, 200))
+                .CheckMeasureResult(new PartialRender(300, 200));
+        }
+        
+        [Test]
+        public void Measure_RotateRight()
+        {
+            TestPlan
+                .For(x => new SimpleRotate
+                {
+                    Child = x.CreateChild(),
+                    TurnCount = 1
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure(new Size(300, 400), new FullRender(200, 300))
+                .CheckMeasureResult(new FullRender(300, 200));
+        }
+        
+        [Test]
+        public void Measure_RotateFlip()
+        {
+            TestPlan
+                .For(x => new SimpleRotate
+                {
+                    Child = x.CreateChild(),
+                    TurnCount = 2
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure(new Size(400, 300), new FullRender(200, 100))
+                .CheckMeasureResult(new FullRender(200, 100));
+        }
+        
+        [Test]
+        public void Measure_RotateLeft()
+        {
+            TestPlan
+                .For(x => new SimpleRotate
+                {
+                    Child = x.CreateChild(),
+                    TurnCount = 3 // or -1
+                })
+                .MeasureElement(new Size(500, 400))
+                .ExpectChildMeasure(new Size(400, 500), new FullRender(300, 350))
+                .CheckMeasureResult(new FullRender(350, 300));
+        }
+        
+        #endregion
+        
+        #region draw
+        
+        [Test]
+        public void Draw_Simple()
+        {
+            TestPlan
+                .For(x => new SimpleRotate
+                {
+                    Child = x.CreateChild(),
+                    TurnCount = 0
+                })
+                .DrawElement(new Size(640, 480))
+                .ExpectCanvasTranslate(0, 0)
+                .ExpectCanvasRotate(0)
+                .ExpectChildDraw(new Size(640, 480))
+                .ExpectCanvasRotate(0)
+                .ExpectCanvasTranslate(0, 0)
+                .CheckDrawResult();
+        }
+        
+        [Test]
+        public void Draw_RotateRight()
+        {
+            TestPlan 
+                .For(x => new SimpleRotate
+                {
+                    Child = x.CreateChild(),
+                    TurnCount = 1
+                })
+                .DrawElement(new Size(640, 480))
+                .ExpectCanvasTranslate(640, 0)
+                .ExpectCanvasRotate(90)
+                .ExpectChildDraw(new Size(480, 640))
+                .ExpectCanvasRotate(-90)
+                .ExpectCanvasTranslate(-640, 0)
+                .CheckDrawResult();
+        }
+        
+        [Test]
+        public void Draw_RotateFlip()
+        {
+            TestPlan 
+                .For(x => new SimpleRotate
+                {
+                    Child = x.CreateChild(),
+                    TurnCount = 2
+                })
+                .DrawElement(new Size(640, 480))
+                .ExpectCanvasTranslate(640, 480)
+                .ExpectCanvasRotate(180)
+                .ExpectChildDraw(new Size(640, 480))
+                .ExpectCanvasRotate(-180)
+                .ExpectCanvasTranslate(-640, -480)
+                .CheckDrawResult();
+        }
+        
+        [Test]
+        public void Draw_RotateLeft()
+        {
+            TestPlan 
+                .For(x => new SimpleRotate
+                {
+                    Child = x.CreateChild(),
+                    TurnCount = 3 // or -1
+                })
+                .DrawElement(new Size(640, 480))
+                .ExpectCanvasTranslate(0, 480)
+                .ExpectCanvasRotate(270)
+                .ExpectChildDraw(new Size(480, 640))
+                .ExpectCanvasRotate(-270)
+                .ExpectCanvasTranslate(0, -480)
+                .CheckDrawResult();
+        }
+        
+        #endregion
+    }
+}

QuestPDF.UnitTests/StackTests.cs

@@ -1,6 +1,8 @@
-using NUnit.Framework;
+using FluentAssertions;
+using NUnit.Framework;
 using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
+using QuestPDF.Fluent;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
 
@@ -229,7 +231,81 @@ namespace QuestPDF.UnitTests
         
         #endregion
         
-        // TODO: add tests for the spacing property
+        #region Structure
-        // TODO: add tests for the tree builder method
+        
+        [Test]
+        public void Structure_Simple()
+        { 
+            // arrange
+            var childA = TestPlan.CreateUniqueElement();
+            var childB = TestPlan.CreateUniqueElement();
+            var childC = TestPlan.CreateUniqueElement();
+            var childD = TestPlan.CreateUniqueElement();
+            var childE = TestPlan.CreateUniqueElement();
+
+            const int spacing = 20;
+            
+            // act
+            var structure = new Container();
+            
+            structure.Stack(stack =>
+            {
+                stack.Spacing(spacing);
+                
+                stack.Item().Element(childA);
+                stack.Item().Element(childB);
+                stack.Item().Element(childC);
+                stack.Item().Element(childD);
+                stack.Item().Element(childE);
+            });
+            
+            // assert
+            var expected = new Padding
+            {
+                Bottom = -spacing,
+
+                Child = new SimpleStack
+                {
+                    First = new SimpleStack
+                    {
+                        First = new Padding
+                        {
+                            Bottom = spacing,
+                            Child = childA
+                        },
+                        Second = new Padding
+                        {
+                            Bottom = spacing,
+                            Child = childB
+                        }
+                    },
+                    Second = new SimpleStack
+                    {
+                        First = new Padding
+                        {
+                            Bottom = spacing,
+                            Child = childC
+                        },
+                        Second = new SimpleStack
+                        {
+                            First = new Padding
+                            {
+                                Bottom = spacing,
+                                Child = childD
+                            },
+                            Second = new Padding
+                            {
+                                Bottom = spacing,
+                                Child = childE
+                            }
+                        }
+                    }
+                }
+            };
+
+            TestPlan.CompareOperations(structure, expected);
+        }
+        
+        #endregion
     }
 }

QuestPDF.UnitTests/TestEngine/ElementMock.cs

@@ -11,6 +11,6 @@ namespace QuestPDF.UnitTests.TestEngine
         public Action<Size> DrawFunc { get; set; }
 
         internal override ISpacePlan Measure(Size availableSpace) => MeasureFunc(availableSpace);
-        internal override void Draw(ICanvas canvas, Size availableSpace) => DrawFunc(availableSpace);
+        internal override void Draw(Size availableSpace) => DrawFunc(availableSpace);
     }
 }

QuestPDF.UnitTests/TestEngine/MockCanvas.cs

@@ -4,40 +4,25 @@ using SkiaSharp;
 
 namespace QuestPDF.UnitTests.TestEngine
 {
-    internal class CanvasMock : ICanvas
+    internal class MockCanvas : ICanvas
     {
         public Action<Position> TranslateFunc { get; set; }
+        public Action<float> RotateFunc { get; set; }
+        public Action<float, float> ScaleFunc { get; set; }
         public Action<SKImage, Position, Size> DrawImageFunc { get; set; }
         public Action<string, Position, TextStyle> DrawTextFunc { get; set; }
         public Action<Position, Size, string> DrawRectFunc { get; set; }
-        
+
         public void Translate(Position vector) => TranslateFunc(vector);
+        public void Rotate(float angle) => RotateFunc(angle);
+        public void Scale(float scaleX, float scaleY) => ScaleFunc(scaleX, scaleY);
+
         public void DrawRectangle(Position vector, Size size, string color) => DrawRectFunc(vector, size, color);
         public void DrawText(string text, Position position, TextStyle style) => DrawTextFunc(text, position, style);
         public void DrawImage(SKImage image, Position position, Size size) => DrawImageFunc(image, position, size);
-        public void DrawExternalLink(string url, Size size)
+        
-        {
+        public void DrawExternalLink(string url, Size size) => throw new NotImplementedException();
-            throw new NotImplementedException();
+        public void DrawLocationLink(string locationName, Size size) => throw new NotImplementedException();
-        }
+        public void DrawLocation(string locationName) => throw new NotImplementedException();
-
-        public void DrawLocationLink(string locationName, Size size)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void DrawLocation(string locationName)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void DrawLink(string url, Size size)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Size MeasureText(string text, TextStyle style)
-        {
-            return new Size(text.Length * style.Size, style.Size);
-        }
     }
 }

QuestPDF.UnitTests/TestEngine/OperationRecordingCanvas.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using QuestPDF.Infrastructure;
+using QuestPDF.UnitTests.TestEngine.Operations;
+using SkiaSharp;
+
+namespace QuestPDF.UnitTests.TestEngine
+{
+    internal class OperationRecordingCanvas : ICanvas
+    {
+        public ICollection<OperationBase> Operations { get; } = new List<OperationBase>();
+
+        public void Translate(Position vector) => Operations.Add(new CanvasTranslateOperation(vector));
+        public void Rotate(float angle) => Operations.Add(new CanvasRotateOperation(angle));
+        public void Scale(float scaleX, float scaleY) => Operations.Add(new CanvasScaleOperation(scaleX, scaleY));
+
+        public void DrawRectangle(Position vector, Size size, string color) => Operations.Add(new CanvasDrawRectangleOperation(vector, size, color));
+        public void DrawText(string text, Position position, TextStyle style) => Operations.Add(new CanvasDrawTextOperation(text, position, style));
+        public void DrawImage(SKImage image, Position position, Size size) => Operations.Add(new CanvasDrawImageOperation(position, size));
+        
+        public void DrawExternalLink(string url, Size size) => throw new NotImplementedException();
+        public void DrawLocationLink(string locationName, Size size) => throw new NotImplementedException();
+        public void DrawLocation(string locationName) => throw new NotImplementedException();
+    }
+}

QuestPDF.UnitTests/TestEngine/Operations/CanvasDrawImageOperation.cs

@@ -2,12 +2,12 @@
 
 namespace QuestPDF.UnitTests.TestEngine.Operations
 {
-    internal class CanvasDrawImageOperationBase : OperationBase
+    internal class CanvasDrawImageOperation : OperationBase
     {
         public Position Position { get; }
         public Size Size { get; }
 
-        public CanvasDrawImageOperationBase(Position position, Size size)
+        public CanvasDrawImageOperation(Position position, Size size)
         {
             Position = position;
             Size = size;

QuestPDF.UnitTests/TestEngine/Operations/CanvasDrawRectangleOperation.cs

@@ -2,13 +2,13 @@
 
 namespace QuestPDF.UnitTests.TestEngine.Operations
 {
-    internal class CanvasDrawRectangleOperationBase : OperationBase
+    internal class CanvasDrawRectangleOperation : OperationBase
     {
         public Position Position { get; } 
         public Size Size { get; }
         public string Color { get; }
 
-        public CanvasDrawRectangleOperationBase(Position position, Size size, string color)
+        public CanvasDrawRectangleOperation(Position position, Size size, string color)
         {
             Position = position;
             Size = size;

QuestPDF.UnitTests/TestEngine/Operations/CanvasDrawTextOperation.cs

@@ -2,13 +2,13 @@
 
 namespace QuestPDF.UnitTests.TestEngine.Operations
 {
-    internal class CanvasDrawTextOperationBase : OperationBase
+    internal class CanvasDrawTextOperation : OperationBase
     {
         public string Text { get; }
         public Position Position { get; }
         public TextStyle Style { get; }
 
-        public CanvasDrawTextOperationBase(string text, Position position, TextStyle style)
+        public CanvasDrawTextOperation(string text, Position position, TextStyle style)
         {
             Text = text;
             Position = position;

QuestPDF.UnitTests/TestEngine/Operations/CanvasRotateOperation.cs

@@ -0,0 +1,12 @@
+namespace QuestPDF.UnitTests.TestEngine.Operations
+{
+    public class CanvasRotateOperation : OperationBase
+    {
+        public float Angle { get; }
+
+        public CanvasRotateOperation(float angle)
+        {
+            Angle = angle;
+        }
+    }
+}

QuestPDF.UnitTests/TestEngine/Operations/CanvasScaleOperation.cs

@@ -0,0 +1,14 @@
+namespace QuestPDF.UnitTests.TestEngine.Operations
+{
+    public class CanvasScaleOperation : OperationBase
+    {
+        public float ScaleX { get; }
+        public float ScaleY { get; }
+
+        public CanvasScaleOperation(float scaleX, float scaleY)
+        {
+            ScaleX = scaleX;
+            ScaleY = scaleY;
+        }
+    }
+}

QuestPDF.UnitTests/TestEngine/Operations/CanvasTranslateOperation.cs

@@ -2,11 +2,11 @@
 
 namespace QuestPDF.UnitTests.TestEngine.Operations
 {
-    internal class CanvasTranslateOperationBase : OperationBase
+    internal class CanvasTranslateOperation : OperationBase
     {
         public Position Position { get; }
 
-        public CanvasTranslateOperationBase(Position position)
+        public CanvasTranslateOperation(Position position)
         {
             Position = position;
         }

QuestPDF.UnitTests/TestEngine/Operations/ChildDrawOperation.cs

@@ -2,12 +2,12 @@
 
 namespace QuestPDF.UnitTests.TestEngine.Operations
 {
-    public class ChildDrawOperationBase : OperationBase
+    public class ChildDrawOperation : OperationBase
     {
         public string ChildId { get; }
         public Size Input { get; }
 
-        public ChildDrawOperationBase(string childId, Size input)
+        public ChildDrawOperation(string childId, Size input)
         {
             ChildId = childId;
             Input = input;

QuestPDF.UnitTests/TestEngine/Operations/ChildMeasureOperation.cs

@@ -3,13 +3,13 @@ using QuestPDF.Infrastructure;
 
 namespace QuestPDF.UnitTests.TestEngine.Operations
 {
-    internal class ChildMeasureOperationBase : OperationBase
+    internal class ChildMeasureOperation : OperationBase
     {
         public string ChildId { get; }
         public Size Input { get; }
         public ISpacePlan Output { get; }
 
-        public ChildMeasureOperationBase(string childId, Size input, ISpacePlan output)
+        public ChildMeasureOperation(string childId, Size input, ISpacePlan output)
         {
             ChildId = childId;
             Input = input;

QuestPDF.UnitTests/TestEngine/Operations/ElementMeasureOperation.cs

@@ -2,9 +2,9 @@
 
 namespace QuestPDF.UnitTests.TestEngine.Operations
 {
-    public class ElementMeasureOperationBase : OperationBase
+    public class ElementMeasureOperation : OperationBase
     {
-        public ElementMeasureOperationBase(Size input)
+        public ElementMeasureOperation(Size input)
         {
             
         }

QuestPDF.UnitTests/TestEngine/SimpleContainerTests.cs

@@ -0,0 +1,68 @@
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.UnitTests.TestEngine
+{
+    internal static class SimpleContainerTests
+    {
+        #region measure
+        
+        public static void Measure<TElement>() where TElement : Element, IContainer, new()
+        {
+            Measure_Wrap<TElement>();
+            Measure_PartialRender<TElement>();
+            Measure_FullRender<TElement>();
+        }
+        
+        private static void Measure_Wrap<TElement>() where TElement : Element, IContainer, new()
+        {
+            TestPlan
+                .For(x => new TElement
+                {
+                    Child = x.CreateChild()
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure(new Size(400, 300), new Wrap())
+                .CheckMeasureResult(new Wrap());
+        }
+        
+        private static void Measure_PartialRender<TElement>() where TElement : Element, IContainer, new()
+        {
+            TestPlan
+                .For(x => new TElement
+                {
+                    Child = x.CreateChild()
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure(new Size(400, 300), new PartialRender(200, 100))
+                .CheckMeasureResult(new PartialRender(200, 100));
+        }
+        
+        private static void Measure_FullRender<TElement>() where TElement : Element, IContainer, new()
+        {
+            TestPlan
+                .For(x => new TElement
+                {
+                    Child = x.CreateChild()
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure(new Size(400, 300), new FullRender(250, 150))
+                .CheckMeasureResult(new FullRender(250, 150));
+        }
+        
+        #endregion
+        
+        public static void Draw<TElement>() where TElement : Element, IContainer, new()
+        {
+            TestPlan
+                .For(x => new TElement
+                {
+                    Child = x.CreateChild()
+                })
+                .DrawElement(new Size(1200, 900))
+                .ExpectChildDraw(new Size(1200, 900))
+                .CheckDrawResult();
+        }
+    }
+}

QuestPDF.UnitTests/TestEngine/SingleChildTests.cs

@@ -1,31 +0,0 @@
-using FluentAssertions;
-using NUnit.Framework;
-using QuestPDF.Drawing.SpacePlan;
-using QuestPDF.Infrastructure;
-
-namespace QuestPDF.UnitTests.TestEngine
-{
-    public static class SingleChildTests
-    {
-        internal static void MeasureWithoutChild<T>(this T element) where T : ContainerElement
-        {
-            element.Child = null;
-            element.Measure(Size.Zero).Should().BeEquivalentTo(new FullRender(Size.Zero));
-        }
-        
-        internal static void DrawWithoutChild<T>(this T element) where T : ContainerElement
-        {
-            // component does not throw an exception when called with null child
-            Assert.DoesNotThrow(() =>
-            {
-                element.Child = null;
-                
-                // component does not perform any canvas operation when called with null child
-                TestPlan
-                    .For(x => element)
-                    .DrawElement(new Size(200, 100))
-                    .CheckDrawResult();
-            });
-        }
-    }
-}

QuestPDF.UnitTests/TestEngine/TestPlan.cs

@@ -1,9 +1,12 @@
 using System;
 using System.Collections.Generic;
 using System.Text.Json;
+using FluentAssertions;
 using NUnit.Framework;
+using QuestPDF.Drawing;
 using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
+using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine.Operations;
 
@@ -12,6 +15,8 @@ namespace QuestPDF.UnitTests.TestEngine
     internal class TestPlan
     {
         private const string DefaultChildName = "child";
+
+        private static Random Random { get; } = new Random();
         
         private Element Element { get; set; }
         private ICanvas Canvas { get; }
@@ -44,20 +49,31 @@ namespace QuestPDF.UnitTests.TestEngine
         
         private ICanvas CreateCanvas()
         {
-            return new CanvasMock
+            return new MockCanvas
             {
                 TranslateFunc = position =>
                 {
-                    var expected = GetExpected<CanvasTranslateOperationBase>();
+                    var expected = GetExpected<CanvasTranslateOperation>();
 
                     Assert.AreEqual(expected.Position.X, position.X, "Translate X");
                     Assert.AreEqual(expected.Position.Y, position.Y, "Translate Y");
-                    
+                },
-                    //position.Should().BeEquivalentTo(expected.Position);
+                RotateFunc = angle =>
+                {
+                    var expected = GetExpected<CanvasRotateOperation>();
+
+                    Assert.AreEqual(expected.Angle, angle, "Rotate angle");
+                },
+                ScaleFunc = (scaleX, scaleY) =>
+                {
+                    var expected = GetExpected<CanvasScaleOperation>();
+
+                    Assert.AreEqual(expected.ScaleX, scaleX, "Scale X");
+                    Assert.AreEqual(expected.ScaleY, scaleY, "Scale Y");
                 },
                 DrawRectFunc = (position, size, color) =>
                 {
-                    var expected = GetExpected<CanvasDrawRectangleOperationBase>();
+                    var expected = GetExpected<CanvasDrawRectangleOperation>();
                     
                     Assert.AreEqual(expected.Position.X, position.X, "Draw rectangle: X");
                     Assert.AreEqual(expected.Position.Y, position.Y, "Draw rectangle: Y");
@@ -66,14 +82,10 @@ namespace QuestPDF.UnitTests.TestEngine
                     Assert.AreEqual(expected.Size.Height, size.Height, "Draw rectangle: height");
                     
                     Assert.AreEqual(expected.Color, color, "Draw rectangle: color");
-                    
-                    /*position.Should().BeEquivalentTo(expected.Position);
-                    size.Should().BeEquivalentTo(expected.Size);
-                    color.Should().Be(expected.Color);*/
                 },
                 DrawTextFunc = (text, position, style) => 
                 {
-                    var expected = GetExpected<CanvasDrawTextOperationBase>();
+                    var expected = GetExpected<CanvasDrawTextOperation>();
                     
                     Assert.AreEqual(expected.Text, text);
                     
@@ -83,23 +95,16 @@ namespace QuestPDF.UnitTests.TestEngine
                     Assert.AreEqual(expected.Style.Color, style.Color, "Draw text: color");
                     Assert.AreEqual(expected.Style.FontType, style.FontType, "Draw text: font");
                     Assert.AreEqual(expected.Style.Size, style.Size, "Draw text: size");
-
-                    /*text.Should().Be(expected.Text);
-                    position.Should().BeEquivalentTo(expected.Position);
-                    style.Should().BeEquivalentTo(expected.Style);*/
                 },
                 DrawImageFunc = (image, position, size) =>
                 {
-                    var expected = GetExpected<CanvasDrawImageOperationBase>();
+                    var expected = GetExpected<CanvasDrawImageOperation>();
                     
                     Assert.AreEqual(expected.Position.X, position.X, "Draw image: X");
                     Assert.AreEqual(expected.Position.Y, position.Y, "Draw image: Y");
                     
                     Assert.AreEqual(expected.Size.Width, size.Width, "Draw image: width");
                     Assert.AreEqual(expected.Size.Height, size.Height, "Draw image: height");
-                    
-                    /*position.Should().BeEquivalentTo(expected.Position);
-                    size.Should().BeEquivalentTo(expected.Size);*/
                 }
             };
         }
@@ -113,29 +118,23 @@ namespace QuestPDF.UnitTests.TestEngine
                 Id = id,
                 MeasureFunc = availableSpace =>
                 {
-                    var expected = GetExpected<ChildMeasureOperationBase>();
+                    var expected = GetExpected<ChildMeasureOperation>();
 
                     Assert.AreEqual(expected.ChildId, id);
                     
                     Assert.AreEqual(expected.Input.Width, availableSpace.Width, $"Measure: width of child '{expected.ChildId}'");
                     Assert.AreEqual(expected.Input.Height, availableSpace.Height, $"Measure: height of child '{expected.ChildId}'");
 
-                    // id.Should().Be(expected.ChildId);
-                    // availableSpace.Should().Be(expected.Input);
-
                     return expected.Output;
                 },
                 DrawFunc = availableSpace =>
                 {
-                    var expected = GetExpected<ChildDrawOperationBase>();
+                    var expected = GetExpected<ChildDrawOperation>();
 
                     Assert.AreEqual(expected.ChildId, id);
                     
                     Assert.AreEqual(expected.Input.Width, availableSpace.Width, $"Draw: width of child '{expected.ChildId}'");
                     Assert.AreEqual(expected.Input.Height, availableSpace.Height, $"Draw: width of child '{expected.ChildId}'");
-                    
-                    /*id.Should().Be(expected.ChildId);
-                    availableSpace.Should().Be(expected.Input);*/
                 }
             };
         }
@@ -165,7 +164,7 @@ namespace QuestPDF.UnitTests.TestEngine
         
         public TestPlan ExpectChildMeasure(string child, Size expectedInput, ISpacePlan returns)
         {
-            return AddOperation(new ChildMeasureOperationBase(child, expectedInput, returns));
+            return AddOperation(new ChildMeasureOperation(child, expectedInput, returns));
         }
         
         public TestPlan ExpectChildDraw(Size expectedInput)
@@ -175,36 +174,48 @@ namespace QuestPDF.UnitTests.TestEngine
         
         public TestPlan ExpectChildDraw(string child, Size expectedInput)
         {
-            return AddOperation(new ChildDrawOperationBase(child, expectedInput));
+            return AddOperation(new ChildDrawOperation(child, expectedInput));
         }
 
         public TestPlan ExpectCanvasTranslate(Position position)
         {
-            return AddOperation(new CanvasTranslateOperationBase(position));
+            return AddOperation(new CanvasTranslateOperation(position));
         }
         
         public TestPlan ExpectCanvasTranslate(float left, float top)
         {
-            return AddOperation(new CanvasTranslateOperationBase(new Position(left, top)));
+            return AddOperation(new CanvasTranslateOperation(new Position(left, top)));
         }
 
+        public TestPlan ExpectCanvasScale(float scaleX, float scaleY)
+        {
+            return AddOperation(new CanvasScaleOperation(scaleX, scaleY));
+        }
+        
+        public TestPlan ExpectCanvasRotate(float angle)
+        {
+            return AddOperation(new CanvasRotateOperation(angle));
+        }
+        
         public TestPlan ExpectCanvasDrawRectangle(Position position, Size size, string color)
         {
-            return AddOperation(new CanvasDrawRectangleOperationBase(position, size, color));
+            return AddOperation(new CanvasDrawRectangleOperation(position, size, color));
         }
         
         public TestPlan ExpectCanvasDrawText(string text, Position position, TextStyle style)
         {
-            return AddOperation(new CanvasDrawTextOperationBase(text, position, style));
+            return AddOperation(new CanvasDrawTextOperation(text, position, style));
         }
         
         public TestPlan ExpectCanvasDrawImage(Position position, Size size)
         {
-            return AddOperation(new CanvasDrawImageOperationBase(position, size));
+            return AddOperation(new CanvasDrawImageOperation(position, size));
         }
         
         public TestPlan CheckMeasureResult(ISpacePlan expected)
         {
+            Element.HandleVisitor(x => x?.Initialize(null, Canvas));
+            
             var actual = Element.Measure(OperationInput);
             
             Assert.AreEqual(expected.GetType(), actual.GetType());
@@ -223,7 +234,8 @@ namespace QuestPDF.UnitTests.TestEngine
         
         public TestPlan CheckDrawResult()
         {
-            Element.Draw(Canvas, OperationInput);
+            Element.HandleVisitor(x => x?.Initialize(null, Canvas));
+            Element.Draw(OperationInput);
             return this;
         }
 
@@ -242,10 +254,51 @@ namespace QuestPDF.UnitTests.TestEngine
         
         public static Element CreateUniqueElement()
         {
-            return new Text
+            return new Constrained
             {
-                Value = Guid.NewGuid().ToString("N")
+                MinWidth = 90,
+                MinHeight = 60,
+                
+                Child = new DynamicImage
+                {
+                    Source = Placeholders.Image
+                }
             };
         }
+
+        public static void CompareOperations(Element value, Element expected, Size? availableSpace = null)
+        {
+            CompareMeasureOperations(value, expected, availableSpace);
+            CompareDrawOperations(value, expected, availableSpace);
+        }
+        
+        private static void CompareMeasureOperations(Element value, Element expected, Size? availableSpace = null)
+        {
+            availableSpace ??= new Size(400, 300);
+            
+            var canvas = new FreeCanvas();
+            value.HandleVisitor(x => x.Initialize(null, canvas));
+            var valueMeasure = value.Measure(availableSpace);
+            
+            expected.HandleVisitor(x => x.Initialize(null, canvas));
+            var expectedMeasure = expected.Measure(availableSpace);
+            
+            valueMeasure.Should().BeEquivalentTo(expectedMeasure);
+        }
+        
+        private static void CompareDrawOperations(Element value, Element expected, Size? availableSpace = null)
+        {
+            availableSpace ??= new Size(400, 300);
+            
+            var valueCanvas = new OperationRecordingCanvas();
+            value.HandleVisitor(x => x.Initialize(null, valueCanvas));
+            value.Draw(availableSpace);
+            
+            var expectedCanvas = new OperationRecordingCanvas();
+            expected.HandleVisitor(x => x.Initialize(null, expectedCanvas));
+            expected.Draw(availableSpace);
+            
+            valueCanvas.Operations.Should().BeEquivalentTo(expectedCanvas.Operations);
+        }
     }
 }

QuestPDF.UnitTests/TestsBase.cs

@@ -0,0 +1,22 @@
+using FluentAssertions;
+using NUnit.Framework;
+
+namespace QuestPDF.UnitTests
+{
+    [SetUpFixture]
+    public class TestsBase
+    {
+        [OneTimeSetUp]
+        public void RunBeforeAnyTests()
+        {
+            AssertionOptions.AssertEquivalencyUsing(options => options
+                .IncludingNestedObjects()
+                .IncludingInternalProperties()
+                .IncludingInternalFields()
+                .AllowingInfiniteRecursion()
+                .RespectingRuntimeTypes()
+                .WithTracing()
+                .WithStrictOrdering());
+        }
+    }
+}

QuestPDF.UnitTests/TextTests.cs

@@ -1,10 +0,0 @@
-using NUnit.Framework;
-
-namespace QuestPDF.UnitTests
-{
-    [TestFixture]
-    public class TextTests
-    {
-        
-    }
-}

QuestPDF.UnitTests/TranslateTests.cs

@@ -0,0 +1,32 @@
+using NUnit.Framework;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+using QuestPDF.UnitTests.TestEngine;
+
+namespace QuestPDF.UnitTests
+{
+    [TestFixture]
+    public class TranslateTests
+    {
+        [Test]
+        public void Measure() => SimpleContainerTests.Measure<Translate>();
+        
+        [Test]
+        public void Draw()
+        {
+            TestPlan
+                .For(x => new Translate
+                {
+                    Child = x.CreateChild(),
+                    TranslateX = 50,
+                    TranslateY = 75
+                })
+                .DrawElement(new Size(400, 300))
+                .ExpectCanvasTranslate(50, 75)
+                .ExpectChildDraw(new Size(400, 300))
+                .ExpectCanvasTranslate(-50, -75)
+                .CheckDrawResult();
+        }
+    }
+}

QuestPDF.UnitTests/UnconstrainedTests.cs

@@ -0,0 +1,100 @@
+using NUnit.Framework;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+using QuestPDF.UnitTests.TestEngine;
+
+namespace QuestPDF.UnitTests
+{
+    [TestFixture]
+    public class UnconstrainedTests
+    {
+        #region measure
+        
+        [Test]
+        public void Measure_Wrap()
+        {
+            TestPlan
+                .For(x => new Unconstrained
+                {
+                    Child = x.CreateChild()
+                })
+                .MeasureElement(new Size(900, 800))
+                .ExpectChildMeasure(Size.Max, new Wrap())
+                .CheckMeasureResult(new Wrap());
+        }
+        
+        [Test]
+        public void Measure_PartialRender()
+        {
+            TestPlan
+                .For(x => new Unconstrained
+                {
+                    Child = x.CreateChild()
+                })
+                .MeasureElement(new Size(900, 800))
+                .ExpectChildMeasure(Size.Max, new PartialRender(1200, 1600))
+                .CheckMeasureResult(new PartialRender(Size.Zero));
+        }
+        
+        [Test]
+        public void Measure_FullRender()
+        {
+            TestPlan
+                .For(x => new Unconstrained
+                {
+                    Child = x.CreateChild()
+                })
+                .MeasureElement(new Size(900, 800))
+                .ExpectChildMeasure(Size.Max, new FullRender(1200, 1600))
+                .CheckMeasureResult(new FullRender(Size.Zero));
+        }
+        
+        #endregion
+        
+        #region draw
+        
+        [Test]
+        public void Draw_SkipWhenChildWraps()
+        {
+            TestPlan
+                .For(x => new Unconstrained
+                {
+                    Child = x.CreateChild()
+                })
+                .DrawElement(new Size(900, 800))
+                .ExpectChildMeasure(Size.Max, new Wrap())
+                .CheckDrawResult();
+        }
+        
+        [Test]
+        public void Draw_WhenChildPartiallyRenders()
+        {
+            TestPlan
+                .For(x => new Unconstrained
+                {
+                    Child = x.CreateChild()
+                })
+                .DrawElement(new Size(900, 800))
+                .ExpectChildMeasure(Size.Max, new PartialRender(1200, 1600))
+                .ExpectChildDraw(new Size(1200, 1600))
+                .CheckDrawResult();
+        }
+        
+        [Test]
+        public void Draw_WhenChildFullyRenders()
+        {
+            TestPlan
+                .For(x => new Unconstrained
+                {
+                    Child = x.CreateChild()
+                })
+                .DrawElement(new Size(900, 800))
+                .ExpectChildMeasure(Size.Max, new FullRender(1600, 1000))
+                .ExpectChildDraw(new Size(1600, 1000))
+                .CheckDrawResult();
+        }
+        
+        #endregion
+    }
+}

QuestPDF/Drawing/Canvas.cs

@@ -1,59 +0,0 @@
-using QuestPDF.Infrastructure;
-using SkiaSharp;
-
-namespace QuestPDF.Drawing
-{
-    internal class Canvas : ICanvas
-    {
-        internal SKCanvas SkiaCanvas { get; }
-        
-        public Canvas(SKCanvas skiaCanvas)
-        {
-            SkiaCanvas = skiaCanvas;
-        }
-        
-        ~Canvas()
-        {
-            SkiaCanvas.Dispose();
-        }
-
-        public void Translate(Position vector)
-        {
-            SkiaCanvas.Translate(vector.X, vector.Y);
-        }
-
-        public void DrawRectangle(Position vector, Size size, string color)
-        {
-            if (size.Width < Size.Epsilon || size.Height < Size.Epsilon)
-                return;
-
-            var paint = color.ColorToPaint();
-            SkiaCanvas.DrawRect(vector.X, vector.Y, size.Width, size.Height, paint);
-        }
-
-        public void DrawText(string text, Position vector, TextStyle style)
-        {
-            SkiaCanvas.DrawText(text, vector.X, vector.Y, style.ToPaint());
-        }
-
-        public void DrawImage(SKImage image, Position vector, Size size)
-        {
-            SkiaCanvas.DrawImage(image, new SKRect(vector.X, vector.Y, size.Width, size.Height));
-        }
-
-        public void DrawExternalLink(string url, Size size)
-        {
-            SkiaCanvas.DrawUrlAnnotation(new SKRect(0, 0, size.Width, size.Height), url);
-        }
-        
-        public void DrawLocationLink(string locationName, Size size)
-        {
-            SkiaCanvas.DrawLinkDestinationAnnotation(new SKRect(0, 0, size.Width, size.Height), locationName);
-        }
-
-        public void DrawLocation(string locationName)
-        {
-            SkiaCanvas.DrawNamedDestinationAnnotation(new SKPoint(0, 0), locationName);
-        }
-    }
-}

QuestPDF/Drawing/DocumentContainer.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuestPDF.Elements;
+using QuestPDF.Fluent;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Drawing
+{
+    internal class DocumentContainer : IDocumentContainer
+    {
+        internal List<IComponent> Pages { get; set; } = new List<IComponent>();
+        
+        internal Container Compose()
+        {
+            var container = new Container();
+            
+            container
+                .Stack(stack =>
+                {
+                    Pages
+                        .SelectMany(x => new List<Action>()
+                        {
+                            () => stack.Item().PageBreak(),
+                            () => stack.Item().Component(x)
+                        })
+                        .Skip(1)
+                        .ToList()
+                        .ForEach(x => x());
+                });
+
+            return container;
+        }
+    }
+}

QuestPDF/Drawing/DocumentGenerator.cs

@@ -3,10 +3,8 @@ using System.Collections.Generic;
 using System.IO;
 using QuestPDF.Drawing.Exceptions;
 using QuestPDF.Drawing.SpacePlan;
-using QuestPDF.Fluent;
+using QuestPDF.Elements;
-using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
-using SkiaSharp;
 
 namespace QuestPDF.Drawing
 {
@@ -14,115 +12,86 @@ namespace QuestPDF.Drawing
     {
         internal static void GeneratePdf(Stream stream, IDocument document)
         {
-            var content = ElementExtensions.Create(document.Compose);
             var metadata = document.GetMetadata();
+            var canvas = new PdfCanvas(stream, metadata);
+            RenderDocument(canvas, document);
+        }
+        
+        internal static ICollection<byte[]> GenerateImages(IDocument document)
+        {
+            var metadata = document.GetMetadata();
+            var canvas = new ImageCanvas(metadata);
+            RenderDocument(canvas, document);
+
+            return canvas.Images;
+        }
+
+        private static void RenderDocument<TCanvas>(TCanvas canvas, IDocument document)
+            where TCanvas : ICanvas, IRenderingCanvas
+        {
+            var container = new DocumentContainer();
+            document.Compose(container);
+            var content = container.Compose();
             
-            using var pdf = SKDocument.CreatePdf(stream, MapMetadata(metadata));
+            var metadata = document.GetMetadata();
-            var totalPages = 1;
+            var pageContext = new PageContext();
+
+            RenderPass(pageContext, new FreeCanvas(), content, metadata);
+            RenderPass(pageContext, canvas, content, metadata);
+        }
+        
+        private static void RenderPass<TCanvas>(PageContext pageContext, TCanvas canvas, Container content, DocumentMetadata documentMetadata)
+            where TCanvas : ICanvas, IRenderingCanvas
+        {
+            content.HandleVisitor(x => x?.Initialize(pageContext, canvas));
+            content.HandleVisitor(x => (x as IStateResettable)?.ResetState());
+            
+            canvas.BeginDocument();
+
+            var currentPage = 1;
             
             while(true)
             {
-                var spacePlan = content.Measure(metadata.Size);
+                pageContext.SetPageNumber(currentPage);
+                var spacePlan = content.Measure(Size.Max) as Size;
 
-                using var skiaCanvas = pdf.BeginPage(metadata.Size.Width, metadata.Size.Height);
+                if (spacePlan == null)
-                var canvas = new Canvas(skiaCanvas);
+                {
+                    canvas.EndDocument();
+                    ThrowLayoutException();
+                }
 
                 try
                 {
-                    content.Draw(canvas, metadata.Size);
+                    canvas.BeginPage(spacePlan);
+                    content.Draw(spacePlan);
                 }
                 catch (Exception exception)
                 {
-                    pdf.Close();
+                    canvas.EndDocument();
                     throw new DocumentDrawingException("An exception occured during document drawing.", exception);
                 }
 
-                pdf.EndPage();
+                canvas.EndPage();
 
-                if (totalPages >= metadata.DocumentLayoutExceptionThreshold)
+                if (currentPage >= documentMetadata.DocumentLayoutExceptionThreshold)
                 {
-                    pdf.Close();
+                    canvas.EndDocument();
                     throw new DocumentLayoutException("Composed layout generates infinite document.");
                 }
                 
                 if (spacePlan is FullRender)
                     break;
 
-                totalPages++;
+                currentPage++;
             }
             
-            pdf.Close();
+            canvas.EndDocument();
-        }
+            
-
+            void ThrowLayoutException()
-        internal static IEnumerable<byte[]> GenerateImages(IDocument document)
-        {
-            var content = ElementExtensions.Create(document.Compose);
-            var metadata = document.GetMetadata();
-
-            var totalPages = 1;
-
-            while (true)
             {
-                var spacePlan = content.Measure(metadata.Size);
+                throw new DocumentLayoutException("Composed layout generates infinite document.");
-                byte[] result;
-
-                try
-                {
-                    result = RenderPage(content);
-                }
-                catch (Exception exception)
-                {
-                    throw new DocumentDrawingException("An exception occured during document drawing.", exception);
-                }
-
-                yield return result;
-
-                if (totalPages >= metadata.DocumentLayoutExceptionThreshold)
-                {
-                    throw new DocumentLayoutException("Composed layout generates infinite document.");
-                }
-
-                if (spacePlan is FullRender)
-                    break;
-
-                totalPages++;
             }
-
-            byte[] RenderPage(Element element)
-            {
-                // scale the result so it is more readable
-                var scalingFactor = metadata.RasterDpi / (float) PageSizes.PointsPerInch;
-                
-                var imageInfo = new SKImageInfo((int) (metadata.Size.Width * scalingFactor), (int) (metadata.Size.Height * scalingFactor));
-                using var surface = SKSurface.Create(imageInfo);
-                surface.Canvas.Scale(scalingFactor);
-
-                var canvas = new Canvas(surface.Canvas);
-                element?.Draw(canvas, metadata.Size);
-
-                surface.Canvas.Save();
-                return surface.Snapshot().Encode(SKEncodedImageFormat.Png, 100).ToArray();
-            }
-        }
-        
-        private static SKDocumentPdfMetadata MapMetadata(DocumentMetadata metadata)
-        {
-            return new SKDocumentPdfMetadata
-            {
-                Title = metadata.Title,
-                Author = metadata.Author,
-                Subject = metadata.Subject,
-                Keywords = metadata.Keywords,
-                Creator = metadata.Creator,
-                Producer = metadata.Producer,
-                
-                Creation = metadata.CreationDate,
-                Modified = metadata.ModifiedDate,
-                
-                RasterDpi = metadata.RasterDpi,
-                EncodingQuality = metadata.ImageQuality,
-                PdfA = metadata.PdfA
-            };
         }
     }
 }

QuestPDF/Drawing/DocumentMetadata.cs

@@ -1,12 +1,9 @@
 using System;
-using QuestPDF.Helpers;
-using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Drawing
 {
     public class DocumentMetadata
     {
-        public Size Size { get; set; } = PageSizes.A4;
         public int ImageQuality { get; set; } = 101;
         public int RasterDpi { get; set; } = 72;
         public bool PdfA { get; set; }

QuestPDF/Drawing/FontManager.cs

@@ -1,15 +1,24 @@
-using System.Collections.Concurrent;
+using System;
+using System.Collections.Concurrent;
+using System.IO;
 using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Infrastructure;
 using SkiaSharp;
 
 namespace QuestPDF.Drawing
 {
-    internal static class CanvasCache
+    public static class FontManager
     {
+        private static ConcurrentDictionary<string, SKTypeface> Typefaces = new ConcurrentDictionary<string, SKTypeface>();
+        private static ConcurrentDictionary<string, SKFontMetrics> FontMetrics = new ConcurrentDictionary<string, SKFontMetrics>();
         private static ConcurrentDictionary<string, SKPaint> Paints = new ConcurrentDictionary<string, SKPaint>();
         private static ConcurrentDictionary<string, SKPaint> ColorPaint = new ConcurrentDictionary<string, SKPaint>();
 
+        public static void RegisterFontType(string fontName, Stream stream)
+        {
+            Typefaces.TryAdd(fontName, SKTypeface.FromStream(stream));
+        }
+        
         internal static SKPaint ColorToPaint(this string color)
         {
             return ColorPaint.GetOrAdd(color, Convert);
@@ -29,35 +38,30 @@ namespace QuestPDF.Drawing
             
             static SKPaint Convert(TextStyle style)
             {
-                var slant = style.IsItalic ? SKFontStyleSlant.Italic : SKFontStyleSlant.Upright;
-                
                 return new SKPaint
                 {
                     Color = SKColor.Parse(style.Color),
-                    Typeface = SKTypeface.FromFamilyName(style.FontType, (int)style.FontWeight, (int)SKFontStyleWidth.Normal, slant),
+                    Typeface = GetTypeface(style),
                     TextSize = style.Size,
-                    TextEncoding = SKTextEncoding.Utf32,
+                    TextEncoding = SKTextEncoding.Utf32
-                    
-                    TextAlign = style.Alignment switch
-                    {
-                        HorizontalAlignment.Left => SKTextAlign.Left,
-                        HorizontalAlignment.Center => SKTextAlign.Center,
-                        HorizontalAlignment.Right => SKTextAlign.Right,
-                        _ => SKTextAlign.Left
-                    }
                 };
             }
+
+            static SKTypeface GetTypeface(TextStyle style)
+            {
+                if (Typefaces.TryGetValue(style.FontType, out var result))
+                    return result;
+                
+                var slant = style.IsItalic ? SKFontStyleSlant.Italic : SKFontStyleSlant.Upright;
+                
+                return SKTypeface.FromFamilyName(style.FontType, (int)style.FontWeight, (int)SKFontStyleWidth.Normal, slant) 
+                       ?? throw new ArgumentException($"The typeface {style.FontType} could not be found.");
+            }
         }
 
-        internal static TextMeasurement BreakText(this TextStyle style, string text, float availableWidth)
+        internal static SKFontMetrics ToFontMetrics(this TextStyle style)
         {
-            var index = (int)style.ToPaint().BreakText(text, availableWidth, out var width);
+            return FontMetrics.GetOrAdd(style.ToString(), key => style.ToPaint().FontMetrics);
-            
-            return new TextMeasurement()
-            {
-                LineIndex = index,
-                FragmentWidth = width
-            };
         }
     }
 }

QuestPDF/Drawing/FreeCanvas.cs

@@ -0,0 +1,81 @@
+using QuestPDF.Infrastructure;
+using SkiaSharp;
+
+namespace QuestPDF.Drawing
+{
+    internal class FreeCanvas : ICanvas, IRenderingCanvas
+    {
+        #region IRenderingCanvas
+
+        public void BeginDocument()
+        {
+            
+        }
+
+        public void EndDocument()
+        {
+            
+        }
+
+        public void BeginPage(Size size)
+        {
+            
+        }
+
+        public void EndPage()
+        {
+            
+        }
+
+        #endregion
+
+        #region ICanvas
+
+        public void Translate(Position vector)
+        {
+            
+        }
+
+        public void DrawRectangle(Position vector, Size size, string color)
+        {
+            
+        }
+
+        public void DrawText(string text, Position position, TextStyle style)
+        {
+            
+        }
+
+        public void DrawImage(SKImage image, Position position, Size size)
+        {
+            
+        }
+
+        public void DrawExternalLink(string url, Size size)
+        {
+           
+        }
+
+        public void DrawLocationLink(string locationName, Size size)
+        {
+            
+        }
+
+        public void DrawLocation(string locationName)
+        {
+            
+        }
+
+        public void Rotate(float angle)
+        {
+            
+        }
+
+        public void Scale(float scaleX, float scaleY)
+        {
+            
+        }
+
+        #endregion
+    }
+}

QuestPDF/Drawing/ImageCanvas.cs

@@ -0,0 +1,52 @@
+using System.Collections.Generic;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+using SkiaSharp;
+
+namespace QuestPDF.Drawing
+{
+    internal class ImageCanvas : SkiaCanvasBase
+    {
+        private DocumentMetadata Metadata { get; }
+        private SKSurface Surface { get; set; }
+
+        internal ICollection<byte[]> Images { get; } = new List<byte[]>();
+        
+        public ImageCanvas(DocumentMetadata metadata)
+        {
+            Metadata = metadata;
+        }
+        
+        public override void BeginDocument()
+        {
+            
+        }
+
+        public override void EndDocument()
+        {
+            Canvas?.Dispose();
+            Surface?.Dispose();
+        }
+
+        public override void BeginPage(Size size)
+        {
+            var scalingFactor = Metadata.RasterDpi / (float) PageSizes.PointsPerInch;
+            var imageInfo = new SKImageInfo((int) (size.Width * scalingFactor), (int) (size.Height * scalingFactor));
+            
+            Surface = SKSurface.Create(imageInfo);
+            Canvas = Surface.Canvas;
+            
+            Canvas.Scale(scalingFactor);
+        }
+
+        public override void EndPage()
+        {
+            Canvas.Save();
+            var image = Surface.Snapshot().Encode(SKEncodedImageFormat.Png, 100).ToArray();
+            Images.Add(image);
+            
+            Canvas.Dispose();
+            Surface.Dispose();
+        }
+    }
+}

QuestPDF/Drawing/PdfCanvas.cs

@@ -0,0 +1,65 @@
+using System.IO;
+using QuestPDF.Infrastructure;
+using SkiaSharp;
+
+namespace QuestPDF.Drawing
+{
+    internal class PdfCanvas : SkiaCanvasBase
+    {
+        private SKDocument Document { get; }
+
+        public PdfCanvas(Stream stream, DocumentMetadata documentMetadata)
+        {
+            Document = SKDocument.CreatePdf(stream, MapMetadata(documentMetadata));
+        }
+
+        ~PdfCanvas()
+        {
+            Document.Dispose();
+        }
+        
+        public override void BeginDocument()
+        {
+            
+        }
+
+        public override void EndDocument()
+        {
+            Canvas.Dispose();
+            
+            Document.Close();
+            Document.Dispose();
+        }
+
+        public override void BeginPage(Size size)
+        {
+            Canvas = Document.BeginPage(size.Width, size.Height);
+        }
+
+        public override void EndPage()
+        {
+            Document.EndPage();
+            Canvas.Dispose();
+        }
+        
+        private static SKDocumentPdfMetadata MapMetadata(DocumentMetadata metadata)
+        {
+            return new SKDocumentPdfMetadata
+            {
+                Title = metadata.Title,
+                Author = metadata.Author,
+                Subject = metadata.Subject,
+                Keywords = metadata.Keywords,
+                Creator = metadata.Creator,
+                Producer = metadata.Producer,
+                
+                Creation = metadata.CreationDate,
+                Modified = metadata.ModifiedDate,
+                
+                RasterDpi = metadata.RasterDpi,
+                EncodingQuality = metadata.ImageQuality,
+                PdfA = metadata.PdfA
+            };
+        }
+    }
+}

QuestPDF/Drawing/SkiaCanvasBase.cs

@@ -0,0 +1,65 @@
+using QuestPDF.Infrastructure;
+using SkiaSharp;
+
+namespace QuestPDF.Drawing
+{
+    internal abstract class SkiaCanvasBase : ICanvas, IRenderingCanvas
+    {
+        internal SKCanvas Canvas { get; set; }
+
+        public abstract void BeginDocument();
+        public abstract void EndDocument();
+        
+        public abstract void BeginPage(Size size);
+        public abstract void EndPage();
+        
+        public void Translate(Position vector)
+        {
+            Canvas.Translate(vector.X, vector.Y);
+        }
+
+        public void DrawRectangle(Position vector, Size size, string color)
+        {
+            if (size.Width < Size.Epsilon || size.Height < Size.Epsilon)
+                return;
+
+            var paint = color.ColorToPaint();
+            Canvas.DrawRect(vector.X, vector.Y, size.Width, size.Height, paint);
+        }
+
+        public void DrawText(string text, Position vector, TextStyle style)
+        {
+            Canvas.DrawText(text, vector.X, vector.Y, style.ToPaint());
+        }
+
+        public void DrawImage(SKImage image, Position vector, Size size)
+        {
+            Canvas.DrawImage(image, new SKRect(vector.X, vector.Y, size.Width, size.Height));
+        }
+
+        public void DrawExternalLink(string url, Size size)
+        {
+            Canvas.DrawUrlAnnotation(new SKRect(0, 0, size.Width, size.Height), url);
+        }
+        
+        public void DrawLocationLink(string locationName, Size size)
+        {
+            Canvas.DrawLinkDestinationAnnotation(new SKRect(0, 0, size.Width, size.Height), locationName);
+        }
+
+        public void DrawLocation(string locationName)
+        {
+            Canvas.DrawNamedDestinationAnnotation(new SKPoint(0, 0), locationName);
+        }
+
+        public void Rotate(float angle)
+        {
+            Canvas.RotateDegrees(angle);
+        }
+
+        public void Scale(float scaleX, float scaleY)
+        {
+            Canvas.Scale(scaleX, scaleY);
+        }
+    }
+}

QuestPDF/Drawing/SpacePlan/TextRender.cs

@@ -0,0 +1,13 @@
+namespace QuestPDF.Drawing.SpacePlan
+{
+    internal class TextRender : FullRender
+    {
+        public float Ascent { get; set; }
+        public float Descent { get; set; }
+        
+        public TextRender(float width, float height) : base(width, height)
+        {
+            
+        }
+    }
+}

QuestPDF/Elements/Alignment.cs

@@ -8,7 +8,7 @@ namespace QuestPDF.Elements
         public VerticalAlignment Vertical { get; set; } = VerticalAlignment.Top;
         public HorizontalAlignment Horizontal { get; set; } = HorizontalAlignment.Left;
         
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
             if (Child == null)
                 return;
@@ -21,9 +21,9 @@ namespace QuestPDF.Elements
             var top = GetTopOffset(availableSpace, childSize);
             var left = GetLeftOffset(availableSpace, childSize);
             
-            canvas.Translate(new Position(left, top));
+            Canvas.Translate(new Position(left, top));
-            Child.Draw(canvas, childSize);
+            Child.Draw(childSize);
-            canvas.Translate(new Position(-left, -top));
+            Canvas.Translate(new Position(-left, -top));
         }
         
         private float GetTopOffset(Size availableSpace, Size childSize)

QuestPDF/Elements/AspectRatio.cs

@@ -36,13 +36,13 @@ namespace QuestPDF.Elements
             throw new NotSupportedException();
         }
 
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
             if (Child == null)
                 return;
             
             var size = GetTargetSize(availableSpace);
-            Child?.Draw(canvas, size);
+            Child?.Draw(size);
         }
         
         private Size GetTargetSize(Size availableSpace)

QuestPDF/Elements/Background.cs

@@ -7,10 +7,10 @@ namespace QuestPDF.Elements
     {
         public string Color { get; set; } = Colors.Black;
         
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
-            canvas.DrawRectangle(Position.Zero, availableSpace, Color);
+            Canvas.DrawRectangle(Position.Zero, availableSpace, Color);
-            Child?.Draw(canvas, availableSpace);
+            Child?.Draw(availableSpace);
         }
     }
 }

QuestPDF/Elements/Border.cs

@@ -12,26 +12,26 @@ namespace QuestPDF.Elements
         public float Bottom { get; set; }
         public float Left { get; set; }
 
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
-            Child?.Draw(canvas, availableSpace);
+            Child?.Draw(availableSpace);
             
-            canvas.DrawRectangle(
+            Canvas.DrawRectangle(
                 new Position(-Left/2, -Top/2), 
                 new Size(availableSpace.Width + Left/2 + Right/2, Top), 
                 Color);
             
-            canvas.DrawRectangle(
+            Canvas.DrawRectangle(
                 new Position(-Left/2, -Top/2), 
                 new Size(Left, availableSpace.Height + Top/2 + Bottom/2), 
                 Color);
             
-            canvas.DrawRectangle(
+            Canvas.DrawRectangle(
                 new Position(-Left/2, availableSpace.Height-Bottom/2), 
                 new Size(availableSpace.Width + Left/2 + Right/2, Bottom), 
                 Color);
             
-            canvas.DrawRectangle(
+            Canvas.DrawRectangle(
                 new Position(availableSpace.Width-Right/2, -Top/2), 
                 new Size(Right, availableSpace.Height + Top/2 + Bottom/2), 
                 Color);

QuestPDF/Elements/Box.cs

@@ -4,14 +4,14 @@ namespace QuestPDF.Elements
 {
     internal class Box : ContainerElement
     {
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
             var targetSize = Child?.Measure(availableSpace) as Size;
             
             if (targetSize == null)
                 return;
             
-            Child?.Draw(canvas, targetSize);
+            Child?.Draw(targetSize);
         }
     }
 }

QuestPDF/Elements/Canvas.cs

@@ -15,9 +15,9 @@ namespace QuestPDF.Elements
             return new FullRender(availableSpace);
         }
 
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
-            var skiaCanvas = (canvas as Drawing.Canvas)?.SkiaCanvas;
+            var skiaCanvas = (Canvas as Drawing.SkiaCanvasBase)?.Canvas;
             
             if (Handler == null || skiaCanvas == null)
                 return;

QuestPDF/Elements/Constrained.cs

@@ -44,13 +44,13 @@ namespace QuestPDF.Elements
             throw new NotSupportedException();
         }
         
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
             var available = new Size(
                 MathHelpers.Min(MaxWidth, availableSpace.Width),
                 MathHelpers.Min(MaxHeight, availableSpace.Height));
             
-            Child?.Draw(canvas, available);
+            Child?.Draw(available);
         }
     }
     

QuestPDF/Elements/Decoration.cs

@@ -15,7 +15,15 @@ namespace QuestPDF.Elements
     {
         public Element DecorationElement { get; set; } = Empty.Instance;
         public Element ContentElement { get; set; } = Empty.Instance;
-        public DecorationType Type { get; set; } 
+        public DecorationType Type { get; set; }
+
+        internal override void HandleVisitor(Action<Element?> visit)
+        {
+            DecorationElement?.HandleVisitor(visit);
+            ContentElement?.HandleVisitor(visit);
+            
+            base.HandleVisitor(visit);
+        }
 
         internal override ISpacePlan Measure(Size availableSpace)
         {
@@ -42,22 +50,22 @@ namespace QuestPDF.Elements
             throw new NotSupportedException();
         }
 
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
             var decorationSize = DecorationElement?.Measure(availableSpace) as Size ?? Size.Zero;
             var contentSize = new Size(availableSpace.Width, availableSpace.Height - decorationSize.Height);
 
             var translateHeight = Type == DecorationType.Prepend ? decorationSize.Height : contentSize.Height;
-            Action drawDecoration = () => DecorationElement?.Draw(canvas, new Size(availableSpace.Width, decorationSize.Height));
+            Action drawDecoration = () => DecorationElement?.Draw(new Size(availableSpace.Width, decorationSize.Height));
-            Action drawContent = () => ContentElement?.Draw(canvas, new Size (availableSpace.Width, contentSize.Height));
+            Action drawContent = () => ContentElement?.Draw(new Size (availableSpace.Width, contentSize.Height));
 
             var first = Type == DecorationType.Prepend ? drawDecoration : drawContent;
             var second = Type == DecorationType.Prepend ? drawContent : drawDecoration;
 
             first();
-            canvas.Translate(new Position(0, translateHeight));
+            Canvas.Translate(new Position(0, translateHeight));
             second();
-            canvas.Translate(new Position(0, -translateHeight));
+            Canvas.Translate(new Position(0, -translateHeight));
         }
     }
     

QuestPDF/Elements/DynamicImage.cs

@@ -14,7 +14,7 @@ namespace QuestPDF.Elements
             return new FullRender(availableSpace.Width, availableSpace.Height);
         }
 
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
             var imageData = Source?.Invoke(availableSpace);
             
@@ -26,7 +26,8 @@ namespace QuestPDF.Elements
                 InternalImage = SKImage.FromEncodedData(imageData)
             };
             
-            imageElement.Draw(canvas, availableSpace);
+            imageElement.Initialize(PageContext, Canvas);
+            imageElement.Draw(availableSpace);
         }
     }
 }

QuestPDF/Elements/Empty.cs

@@ -12,7 +12,7 @@ namespace QuestPDF.Elements
             return new FullRender(Size.Zero);
         }
 
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
             
         }

QuestPDF/Elements/ExternalLink.cs

@@ -6,15 +6,15 @@ namespace QuestPDF.Elements
     {
         public string Url { get; set; } = "https://www.questpdf.com";
         
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
             var targetSize = Child?.Measure(availableSpace) as Size;
 
             if (targetSize == null)
                 return;
 
-            canvas.DrawExternalLink(Url, targetSize);
+            Canvas.DrawExternalLink(Url, targetSize);
-            Child?.Draw(canvas, availableSpace);
+            Child?.Draw(availableSpace);
         }
     }
 }

QuestPDF/Elements/Grid.cs

@@ -16,7 +16,7 @@ namespace QuestPDF.Elements
     {
         public const int DefaultColumnsCount = 12;
         
-        public List<GridElement> Children { get; set; } = new List<GridElement>();
+        public List<GridElement> Children { get; } = new List<GridElement>();
         public Queue<GridElement> ChildrenQueue { get; set; } = new Queue<GridElement>();
         public int ColumnsCount { get; set; } = DefaultColumnsCount;
 
@@ -30,7 +30,7 @@ namespace QuestPDF.Elements
             
             container.Stack(stack =>
             {
-                stack.Spacing(HorizontalSpacing);
+                stack.Spacing(VerticalSpacing);
                 
                 while (ChildrenQueue.Any())
                     stack.Item().Row(BuildRow);

QuestPDF/Elements/Image.cs

@@ -18,12 +18,12 @@ namespace QuestPDF.Elements
             return new FullRender(availableSpace);
         }
 
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
             if (InternalImage == null)
                 return;
 
-            canvas.DrawImage(InternalImage, Position.Zero, availableSpace);
+            Canvas.DrawImage(InternalImage, Position.Zero, availableSpace);
         }
     }
 }

QuestPDF/Elements/InternalLink.cs

@@ -6,15 +6,15 @@ namespace QuestPDF.Elements
     {
         public string LocationName { get; set; }
         
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
             var targetSize = Child?.Measure(availableSpace) as Size;
 
             if (targetSize == null)
                 return;
 
-            canvas.DrawLocationLink(LocationName, targetSize);
+            Canvas.DrawLocationLink(LocationName, targetSize);
-            Child?.Draw(canvas, availableSpace);
+            Child?.Draw(availableSpace);
         }
     }
 }

QuestPDF/Elements/InternalLocation.cs

@@ -2,14 +2,27 @@
 
 namespace QuestPDF.Elements
 {
-    internal class InternalLocation : ContainerElement
+    internal class InternalLocation : ContainerElement, IStateResettable
     {
         public string LocationName { get; set; }
+        private bool IsRendered { get; set; }
         
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        public void ResetState()
         {
-            canvas.DrawLocation(LocationName);
+            IsRendered = false;
-            Child?.Draw(canvas, availableSpace);
+        }
+        
+        internal override void Draw(Size availableSpace)
+        {
+            if (!IsRendered)
+            {
+                PageContext.SetLocationPage(LocationName);
+                
+                Canvas.DrawLocation(LocationName);
+                IsRendered = true;
+            }
+            
+            Child?.Draw(availableSpace);
         }
     }
 }

QuestPDF/Elements/Layers.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Infrastructure;
@@ -14,6 +15,12 @@ namespace QuestPDF.Elements
     {
         public List<Layer> Children { get; set; } = new List<Layer>();
         
+        internal override void HandleVisitor(Action<Element?> visit)
+        {
+            Children.ForEach(x => x.HandleVisitor(visit));
+            base.HandleVisitor(visit);
+        }
+
         internal override ISpacePlan Measure(Size availableSpace)
         {
             return Children
@@ -21,12 +28,12 @@ namespace QuestPDF.Elements
                 .Measure(availableSpace);
         }
 
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
             Children
                 .Where(x => x.Measure(availableSpace) is Size)
                 .ToList()
-                .ForEach(x => x.Draw(canvas, availableSpace));
+                .ForEach(x => x.Draw(availableSpace));
         }
     }
 }

QuestPDF/Elements/Padding.cs

@@ -39,16 +39,16 @@ namespace QuestPDF.Elements
             throw new NotSupportedException();
         }
 
-        internal override void Draw(ICanvas canvas, Size availableSpace)
+        internal override void Draw(Size availableSpace)
         {
             if (Child == null)
                 return;
 
             var internalSpace = InternalSpace(availableSpace);
             
-            canvas.Translate(new Position(Left, Top));
+            Canvas.Translate(new Position(Left, Top));
-            Child?.Draw(canvas, internalSpace);
+            Child?.Draw(internalSpace);
-            canvas.Translate(new Position(-Left, -Top));
+            Canvas.Translate(new Position(-Left, -Top));
         }
 
         private Size InternalSpace(Size availableSpace)

QuestPDF/Elements/Page.cs

@@ -1,22 +1,56 @@
+using System;
 using QuestPDF.Fluent;
+using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Elements
 {
     internal class Page : IComponent
     {
+        public Size MinSize { get; set; } = PageSizes.A4;
+        public Size MaxSize { get; set; } = PageSizes.A4;
+
+        public float MarginLeft { get; set; }
+        public float MarginRight { get; set; }
+        public float MarginTop { get; set; }
+        public float MarginBottom { get; set; }
+
         public Element Header { get; set; } = Empty.Instance;
         public Element Content { get; set; } = Empty.Instance;
         public Element Footer { get; set; } = Empty.Instance;
 
         public void Compose(IContainer container)
         {
-            container.Decoration(decoration =>
+            container
+
+                .MinWidth(MinSize.Width)
+                .MinHeight(MinSize.Height)
+                
+                .MaxWidth(MaxSize.Width)
+                .MaxHeight(MaxSize.Height)
+     
+                .PaddingLeft(MarginLeft)
+                .PaddingRight(MarginRight)
+                .PaddingTop(MarginTop)
+                .PaddingBottom(MarginBottom)
+                
+                .Decoration(decoration =>
+                {
+                    decoration.Header().Element(Header);
+                    
+                    decoration
+                        .Content()
+                        .Element(x => IsClose(MinSize.Width, MaxSize.Width) ? x.ExtendHorizontal() : x)
+                        .Element(x => IsClose(MinSize.Height, MaxSize.Height) ? x.ExtendVertical() : x)
+                        .Element(Content);
+                    
+                    decoration.Footer().Element(Footer);
+                });
+
+            bool IsClose(float x, float y)
             {
-                decoration.Header().Element(Header);
+                return Math.Abs(x - y) < Size.Epsilon;
-                decoration.Content().Extend().Element(Content);
+            }
-                decoration.Footer().Element(Footer);
-            });
         }
     }
 }