Improved text run calculation

# Conflicts:
#	QuestPDF/Elements/Stack.cs

.github/FUNDING.yml

@@ -1 +0,0 @@
-github: QuestPDF

.github/SECURITY.md

@@ -1,14 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 2021.5.2   | :white_check_mark: |
-| Older   | :x:                |
-
-## Reporting a Vulnerability
-
-Please report any code vulnerabilities using GitHub Issues. We are trying to respond within 1 day and analyze reported situation as soon as possible.
-Please collaborate with us to find best solutation available.
-Once the vulnerability is recognized and fixed, the issue is closed with appropraite message. 

.github/workflows/codeql-analysis.yml

@@ -1,70 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ main ]
-  schedule:
-    - cron: '22 16 * * 5'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'csharp' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
-        # Learn more about CodeQL language support at https://git.io/codeql-language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-        # queries: ./path/to/local/query, your-org/your-repo/queries@main
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 https://git.io/JvXDl
-
-    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
-    #    and modify them (or add more) to build your code if your project
-    #    uses a compiled language
-
-    #- run: |
-    #   make bootstrap
-    #   make release
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1

.github/workflows/dotnet-desktop.yml

@@ -1,54 +0,0 @@
-name: Build And Create Nuget Package
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-  workflow_dispatch:
-  schedule:
-    - cron: '3 0 * * 0'
-
-jobs:
-  main:
-    runs-on: ${{ matrix.environment }}
-    strategy:
-      matrix:
-        environment:
-          - macos-latest
-          - ubuntu-latest
-          - windows-latest
-    env:
-      DOTNET_NOLOGO: 1
-      DOTNET_CLI_TELEMETRY_OPTOUT: 1
-      NUGET_PACKAGES: ${{ github.workspace }}/.nuget/packages
-      UNIT_TEST_PROJECT: QuestPDF.UnitTests/QuestPDF.UnitTests.csproj
-
-    steps:
-      - name: 📝 Fetch Sources 📝
-        uses: actions/checkout@v2
-
-      - name: ⚙ Setup .NET 6.0 SDK ⚙
-        uses: actions/setup-dotnet@v1
-        with:
-          dotnet-version: '6.0.x'
-          
-      - name: 🔄 Restore Nuget Packages 🔄
-        shell: bash
-        run: dotnet restore
-        working-directory: ./Source
-
-      - name: 🛠 Build Solution 🛠
-        shell: bash
-        run: dotnet build -c Release --no-restore
-        working-directory: ./Source
-        
-      - name: Upload build artifacts
-        uses: actions/upload-artifact@v3
-        if: ${{ matrix.environment == 'windows-latest' }}
-        with:
-          name: Build Package
-          path: |
-            **/*.nupkg
-            **/*.snupkg
-            !.nuget

.github/workflows/qodana.yml

@@ -1,19 +0,0 @@
-name: Qodana
-on:
-  workflow_dispatch:
-  pull_request:
-  push:
-    branches:
-      - main
-      - 'releases/*'
-
-jobs:
-  qodana:
-    timeout-minutes: 15
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - name: 'Qodana Scan'
-        uses: JetBrains/qodana-action@v2023.1.0

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 QuestPDF
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

License/CommunityLicense.md

@@ -1,13 +0,0 @@
-# QuestPDF Community MIT License
-
-
-## License Permissions
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-
-## Copyright
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-
-## Limitation Of Liability
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

License/ProfessionalAndEnterpriseUseLicense.md

@@ -1,29 +0,0 @@
-# QuestPDF Professional And Enterprise Use License
-
-
-## Do No Harm
-By downloading or using the Software, the Licensee agrees not to utilize the software in a manner which is disparaging to QuestPDF, and not to rent, lease or otherwise transfer rights to the Software.
-
-
-## License Permissions
-Grants the use of the Software by a specified number of developers to create and deploy closed-source software for unlimited end user organizations ("The Organization") in multiple locations. This license covers unlimited applications or projects. The Software may be deployed upon any number of machines for the end-use of The Organization. This license also intrinsically covers for development, staging and production servers for each project.
-
-Grants the use of the Software by a specified number of developers to create and deploy closed-source software for unlimited end user organizations ("The Organization") in multiple locations. This license covers unlimited applications or projects. The Software may be deployed upon any number of machines for the end-use of The Organization. This license also intrinsically covers for development, staging and production servers for each project.
-
-
-## License Fees
-A. If you wish to use the Software in a production environment, you may download and use the Software for one year upon payment of the appropriate license fee as indicated on the pricing page in accordance with the terms and conditions of this Agreement.
-
-B. If you wish to use the Software in a non-production environment, you may download and access the source and/or binaries at no charge solely for testing and evaluation purposes and in accordance with all license limitations and restrictions set forth in this Agreement.
-
-
-## Ownership
-QuestPDF shall at all times retain ownership of the QuestPDF Software library and all subsequent copies.
-
-
-## Copyright
-Title, ownership rights, and intellectual property rights in and to the Software shall remain with QuestPDF. The Software is protected by the international copyright laws. Title, ownership rights, and intellectual property rights in and to the content accessed through the Software is the property of the applicable content owner and may be protected by applicable copyright or other law. This License gives you no rights to such content.
-
-
-## Limitation Of Liability
-THIS SOFTWARE IS PROVIDED "AS IS," WITHOUT A WARRANTY OF ANY KIND. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. QUESTPDF AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL QUESTPDF OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE SOFTWARE, EVEN IF QUESTPDF HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

License/Readme.md

@@ -1,23 +0,0 @@
-# What License Do You Need?
-
-## General License Overview
-
-Open-source projects are an important foundation for the software development ecosystem. Modern applications are depending more and more upon the work of enthusiast and experts. Open-source is not anymore just sharing knowledge and passion with everybody. Over last years, maintaining and developing those projects have became a highly responsible task.
-
-We identify the importance of the QuestPDF library in your projects, and therefore want to make sure you can safely and confidently continue the development. We strongly believe that a dual-licensing model is the best solution for all users: providing the best development experience and feature set for everybody and every project, but also offering stability for every professional and enterprise product.
-
-Being a healthy and growing community is our primary goal that motivates us to pursue professionalism.
-
-[Read more about exact terms](https://www.questpdf.com/pricing.html)
-
-
-## QuestPDF Professional Or Enterprise Use License
-
-If you are consuming the QuestPDF library as a Direct Package Dependency for usage in a Closed Source software in the capacity of a for-profit company/individual with more than 1M USD annual gross revenue, you must purchase the `QuestPDF Professional or Enterprise` License, depending on number of software developers. [Read more](https://www.questpdf.com/license-commercial.html)
-
-
-## QuestPDF Community MIT License
-
-We love and highly appreciate the .NET Community and therefore the vast majority of users are welcome to use the library completely for free. If you do not meet the criteria described above, you are eligible to use the `QuestPDF Community MIT` License, without any limitations, even for commercial usage. [Read more](https://www.questpdf.com/license-community.html)
-
-If you still want to support library development, please consider purchasing the Professional License.

QuestPDF.Examples/ElementExamples.cs

@@ -0,0 +1,319 @@
+using System.Linq;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+using SkiaSharp;
+
+namespace QuestPDF.Examples
+{
+    public class ElementExamples : ExampleTestBase
+    {
+        //[ShowResult]
+        [ImageSize(200, 150)]
+        public void Placeholder(IContainer container)
+        {
+            container
+                .Background("#FFF")
+                .Padding(25)
+                .Placeholder();
+        }
+        
+        //[ShowResult]
+        [ImageSize(300, 300)]
+        public void Decoration(IContainer container)
+        {
+            container
+                .Background("#FFF")
+                .Padding(25)
+                .Decoration(decoration =>
+                {
+                    decoration
+                        .Header()
+                        .Background("#888")
+                        .Padding(10)
+                        .Text("Notes", TextStyle.Default.Size(16).Color("#FFF"));
+                    
+                    decoration
+                        .Content()
+                        .Background("#DDD")
+                        .Padding(10)
+                        .ExtendVertical()
+                        .Text(Helpers.Placeholders.LoremIpsum());
+                });
+        }
+        
+        //[ShowResult]
+        [ImageSize(298, 421)]
+        public void Page(IContainer container)
+        {
+            container
+                .Background("#FFF")
+                .Padding(15)
+                .Page(page =>
+                {
+                    page.Header()
+                        .Height(60)
+                        .Background("#BBB")
+                        .AlignCenter()
+                        .AlignMiddle()
+                        .Text("Header");
+                    
+                    page.Content()
+                        .Background("#DDD")
+                        .AlignCenter()
+                        .AlignMiddle()
+                        .Text("Content");
+                        
+                    page.Footer()
+                        .Height(30)
+                        .Background("#BBB")
+                        .AlignCenter()
+                        .AlignMiddle()
+                        .Text("Footer");
+                });
+        }
+        
+        //[ShowResult]
+        [ImageSize(740, 200)]
+        public void Row(IContainer container)
+        {
+            container
+                .Background("#FFF")
+                .Padding(20)
+                .Stack(stack =>
+                {
+                    stack.Item()
+                        .PaddingBottom(10)
+                        .AlignCenter()
+                        .Text("This Row element is 700pt wide");
+
+                    stack.Item().Row(row =>
+                    {
+                        row.ConstantColumn(100)
+                            .Background("#DDD")
+                            .Padding(10)
+                            .ExtendVertical()
+                            .Text("This column is 100 pt wide");
+
+                        row.RelativeColumn()
+                            .Background("#BBB")
+                            .Padding(10)
+                            .Text("This column takes 1/3 of the available space (200pt)");
+
+                        row.RelativeColumn(2)
+                            .Background("#DDD")
+                            .Padding(10)
+                            .Text("This column takes 2/3 of the available space (400pt)");
+                    });
+                });
+        }
+        
+        //[ShowResult]
+        [ImageSize(500, 350)]
+        public void Column(IContainer container)
+        {
+            container
+                .Background("#FFF")
+                .Padding(15)
+                .Stack(column =>
+                {
+                    column.Spacing(10);
+                    
+                    column
+                        .Item()
+                        .Background("#999")
+                        .Height(50);
+                    
+                    column
+                        .Item()
+                        .Background("#BBB")
+                        .Height(100);
+                    
+                    column
+                        .Item()
+                        .Background("#DDD")
+                        .Height(150);
+                });
+        }
+        
+        [ShowResult]
+        [ImageSize(210, 210)]
+        public void Debug(IContainer container)
+        {
+            container
+                .Padding(25)
+                .Debug("Grid example", Colors.Blue.Medium)
+                .Grid(grid =>
+                {
+                    grid.Columns(3);
+                    grid.Spacing(5);
+
+                    foreach (var _ in Enumerable.Range(0, 8))
+                        grid.Item().Height(50).Placeholder();
+                });
+        }
+        
+        //[ShowResult]
+        [ImageSize(300, 200)]
+        public void ElementEnd(IContainer container)
+        {
+            var text = "";
+            
+            container
+                .Padding(10)
+                .Element(x =>
+                {
+                    if (string.IsNullOrWhiteSpace(text))
+                        x.Height(10).Width(50).Background("#DDD");
+                    else
+                        x.Text(text);
+                });
+        }
+        
+        //[ShowResult]
+        [ImageSize(300, 200)]
+        public void GridExample(IContainer container)
+        {
+            var textStyle = TextStyle.Default.Size(14);
+            
+            container
+                .Padding(20)
+                .AlignRight()
+                .Grid(grid =>
+                {
+                    grid.VerticalSpacing(20);
+                    grid.HorizontalSpacing(10);
+                    grid.Columns(12);
+
+                    grid.Item(8).Background("#DDD").Height(50).Padding(5).Text("This is a short text", textStyle);
+                    grid.Item(4).Background("#BBB").Padding(5).Text("Showing how to...", textStyle);
+                    grid.Item(2).Background("#999").Height(50);
+                    grid.Item(4).Background("#AAA").Border(2).BorderColor("#666").Padding(5).Text("...generate", textStyle);
+                    grid.Item(6).Background("#CCC").Padding(5).Text("simple grids", textStyle.Size(18).Bold());
+                    grid.Item(8).Background("#DDD").Height(50);
+                });
+        }
+
+        //[ShowResult]
+        [ImageSize(300, 300)]
+        public void RandomColorMatrix(IContainer container)
+        {
+            container
+                .Padding(25)
+                .Grid(grid =>
+                {
+                    grid.Columns(5);
+                    
+                    Enumerable
+                        .Range(0, 25)
+                        .Select(x => Placeholders.BackgroundColor())
+                        .ToList()
+                        .ForEach(x => grid.Item().Height(50).Background(x));
+                });
+        }
+        
+        //[ShowResult]
+        [ImageSize(450, 150)]
+        public void DefinedColors(IContainer container)
+        {
+            var colors = new[]
+            {
+                Colors.Green.Darken4,
+                Colors.Green.Darken3,
+                Colors.Green.Darken2,
+                Colors.Green.Darken1,
+                
+                Colors.Green.Medium,
+                
+                Colors.Green.Lighten1,
+                Colors.Green.Lighten2,
+                Colors.Green.Lighten3,
+                Colors.Green.Lighten4,
+                Colors.Green.Lighten5,
+                
+                Colors.Green.Accent1,
+                Colors.Green.Accent2,
+                Colors.Green.Accent3,
+                Colors.Green.Accent4,
+            };
+            
+            container
+                .Padding(25)
+                .Height(100)
+                .Row(row =>
+                {
+                    foreach (var color in colors)
+                        row.RelativeColumn().Background(color);
+                });
+        }
+        
+        //[ShowResult]
+        [ImageSize(500, 175)]
+        public void DefinedFonts(IContainer container)
+        {
+            var fonts = new[]
+            {
+                Fonts.Calibri,
+                Fonts.Candara,
+                Fonts.Arial,
+                Fonts.TimesNewRoman,
+                Fonts.Consolas,
+                Fonts.Tahoma,
+                Fonts.Impact,
+                Fonts.Trebuchet,
+                Fonts.ComicSans
+            };
+            
+            container
+                .Padding(25)
+                .Grid(grid =>
+                {
+                    grid.Columns(3);
+
+                    foreach (var font in fonts)
+                    {
+                        grid.Item()
+                            .Border(1)
+                            .BorderColor(Colors.Grey.Medium)
+                            .Padding(10)
+                            .Text(font, TextStyle.Default.FontType(font).Size(16));
+                    }
+                });
+        }
+        
+        //[ShowResult]
+        [ImageSize(300, 300)]
+        public void Layers(IContainer container)
+        {
+            container
+                .Background("#FFF")
+                .Padding(25)
+                .Layers(layers =>
+                {
+                    layers.Layer().Text("Something else");
+                    
+                    layers.PrimaryLayer().Stack(stack =>
+                    {
+                        stack.Item().PaddingTop(20).Text("Text 1");
+                        stack.Item().PaddingTop(40).Text("Text 2");
+                    });
+                    
+                    layers.Layer().Canvas((canvas, size) =>
+                    {
+                        using var paint = new SKPaint
+                        {
+                            Color = SKColors.Red,
+                            StrokeWidth = 5
+                        };
+                        
+                        canvas.Translate(size.Width / 2, size.Height / 2);
+                        canvas.DrawCircle(0, 0, 50, paint);
+                    });
+                    
+                    layers.Layer().Background("#8F00").Extend();
+                    layers.Layer().PaddingTop(40).Text("It works!", TextStyle.Default.Size(24));
+                });
+        }
+    }
+}

QuestPDF.Examples/Engine/ExampleTestBase.cs

@@ -0,0 +1,95 @@
+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

@@ -0,0 +1,14 @@
+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

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

QuestPDF.Examples/Engine/ImageSizeAttribute.cs

@@ -0,0 +1,19 @@
+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/ShowResultAttribute.cs

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

QuestPDF.Examples/Engine/SimpleDocument.cs

@@ -0,0 +1,33 @@
+using QuestPDF.Drawing;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples.Engine
+{
+    public class SimpleDocument : IDocument
+    {
+        private IContainer Container { get; }
+        private Size Size { get; }
+
+        public SimpleDocument(IContainer container, Size size)
+        {
+            Container = container;
+            Size = size;
+        }
+        
+        public DocumentMetadata GetMetadata()
+        {
+            return new DocumentMetadata()
+            {
+                RasterDpi = PageSizes.PointsPerInch * 2,
+                Size = Size
+            };
+        }
+
+        public void Compose(IContainer container)
+        {
+            container.Background("#FFF").Element(Container.Child);
+        }
+    }
+}

QuestPDF.Examples/FrameExample.cs

@@ -0,0 +1,44 @@
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples
+{
+    static class SimpleExtension
+    {
+        private static IContainer Cell(this IContainer container, bool dark)
+        {
+            return container
+                .Border(1)
+                .Background(dark ? "#EEE" : "#FFF")
+                .Padding(10);
+        }
+        
+        public static IContainer LabelCell(this IContainer container) => container.Cell(true);
+        public static IContainer ValueCell(this IContainer container) => container.Cell(false);
+    }
+    
+    public class FrameExample: ExampleTestBase
+    {
+        [ImageSize(550, 400)]
+        [ShowResult]
+        public void Frame(IContainer container)
+        {
+            container
+                .Background("#FFF")
+                .Padding(25)
+                .Stack(stack =>
+                {
+                    for(var i=1; i<=4; i++)
+                    {
+                        stack.Item().Row(row =>
+                        {
+                            row.RelativeColumn(2).LabelCell().Text(Placeholders.Label());
+                            row.RelativeColumn(3).ValueCell().Text(Placeholders.Paragraph());
+                        });
+                    }
+                });
+        }
+    }
+}

QuestPDF.Examples/LoremPicsumExample.cs

@@ -0,0 +1,54 @@
+using System.Net;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples
+{
+    public class LoremPicsum : IComponent
+    {
+        public bool Greyscale { get; }
+
+        public LoremPicsum(bool greyscale)
+        {
+            Greyscale = greyscale;
+        }
+        
+        public void Compose(IContainer container)
+        {
+            var url = "https://picsum.photos/300/200";
+
+            if(Greyscale)
+                url += "?grayscale";
+
+            using var client = new WebClient();
+            var response = client.DownloadData(url);
+            container.Image(response);
+        }
+    }
+    
+    public class LoremPicsumExample : ExampleTestBase
+    {
+        [ShowResult]
+        [ImageSize(350, 280)]
+        public void LoremPicsum(IContainer container)
+        {
+            container
+                .Background("#FFF")
+                .Padding(25)
+                .Stack(column =>
+                {
+                    column.Spacing(10);
+
+                    column
+                        .Item()
+                        .Component(new LoremPicsum(true));
+                    
+                    column
+                        .Item()
+                        .AlignRight()
+                        .Text("From Lorem Picsum");
+                });
+        }
+    }
+}

QuestPDF.Examples/Padding.cs

@@ -0,0 +1,134 @@
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples
+{
+    public class Examples : ExampleTestBase
+    {
+        public void Padding(IContainer container)
+        {
+            container
+                .Background("#FDD")
+                .Padding(50)
+
+                .Background("#AFA")
+                .PaddingVertical(50)
+
+                .Background("#77F")
+                .PaddingHorizontal(50)
+
+                .Background("#444");
+        }
+        
+        public void Border(IContainer container)
+        {
+            container
+                .Background("#EEE")
+                .Padding(25)
+
+                .AlignBottom()
+                .AlignCenter()
+                .BorderBottom(2)
+                .BorderColor("#000")
+                
+                .Background("FFF")
+                .Padding(5)
+                .Text("Sample text", TextStyle.Default.FontType("Segoe UI emoji").Alignment(HorizontalAlignment.Center));
+        }
+        
+        public void Alignment(IContainer container)
+        {
+            container
+                .Stack(column =>
+                {
+                    column
+                        .Item()
+                        .Height(100)
+                        .Background("#FFF")
+                        
+                        .AlignLeft()
+                        .AlignMiddle()
+
+                        .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)
+        {
+            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

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netcoreapp3.1</TargetFramework>
+        <IsPackable>false</IsPackable>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="nunit" Version="3.12.0" />
+        <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
+        <PackageReference Include="SkiaSharp" Version="2.80.2" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\QuestPDF\QuestPDF.csproj" />
+    </ItemGroup>
+
+</Project>

QuestPDF.Examples/TextExample.cs

@@ -0,0 +1,212 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using QuestPDF.Elements;
+using QuestPDF.Examples.Engine;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+using SkiaSharp;
+
+namespace QuestPDF.Examples
+{
+    public class TextExample : ExampleTestBase
+    {
+        [ShowResult]
+        [ImageSize(1400, 600)]
+        public void OldText(IContainer container)
+        {
+            var fonts = new[]
+            {
+                Fonts.Arial,
+                Fonts.Calibri,
+                Fonts.Cambria,
+                Fonts.Candara,
+                Fonts.ComicSans,
+                Fonts.Consolas,
+                Fonts.Corbel,
+                Fonts.Courier,
+                Fonts.CourierNew,
+                Fonts.Georgia,
+                Fonts.Impact,
+                Fonts.LucidaConsole,
+                Fonts.SegoeSD,
+                Fonts.SegoeUI,
+                Fonts.Tahoma,
+                Fonts.TimesNewRoman,
+                Fonts.TimesRoman,
+                Fonts.Trebuchet,
+                Fonts.Verdana,
+            };
+            
+            container
+                .Padding(50)
+                .Grid(stack =>
+                {
+                    stack.Spacing(10);
+                    stack.Columns(2);
+
+                    foreach (var font in fonts)
+                    {
+                        stack
+                            .Element()
+                            .Box()
+                            .Background(Placeholders.BackgroundColor())
+                            .Text($"Lorem ipsum dolor sit amet {font}", TextStyle.Default.Size(24).FontType(font));
+                    }
+                });
+        }
+        
+        //[ShowResult]
+        [ImageSize(1400, 800)]
+        public void Test(IContainer container)
+        {
+            List<TextElement> Lorem()
+            {
+                return new List<TextElement>
+                {
+                    new TextElement()
+                    {
+                        Style = TextStyle.Default.Size(32).BackgroundColor(Placeholders.BackgroundColor()),
+                        Text = "Podstawowy łaciński Tabela znaków Unicode"
+                    },
+                    new TextElement()
+                    {
+                        Style = TextStyle.Default.FontType("Segoe UI Emoji").Size(32).BackgroundColor(Placeholders.BackgroundColor()),
+                        Text = "✔"
+                    },
+                    new TextElement()
+                    {
+                        Style = TextStyle.Default.FontType("Segoe UI Emoji").Size(32).BackgroundColor(Placeholders.BackgroundColor()),
+                        Text = "🥛"
+                    },
+                    new TextElement()
+                    {
+                        Style = TextStyle.Default.FontType("Segoe UI Emoji").Size(32).BackgroundColor(Placeholders.BackgroundColor()),
+                        Text = "🧀"
+                    },
+                    new TextElement()
+                    {
+                        Style = TextStyle.Default.FontType("Segoe UI Emoji").Size(32).BackgroundColor(Placeholders.BackgroundColor()),
+                        Text = "❤🚵‍♀️"
+                    },
+                    new TextElement()
+                    {
+                        Style = TextStyle.Default.Size(32).BackgroundColor(Placeholders.BackgroundColor()),
+                        Text = "Lorem ipsum "
+                    },
+                    new TextElement()
+                    {
+                        Style = TextStyle.Default.Size(24).BackgroundColor(Placeholders.BackgroundColor()),
+                        Text = " dolor "
+                    },
+                    new TextElement()
+                    {
+                        Style = TextStyle.Default.Size(64).BackgroundColor(Placeholders.BackgroundColor()),
+                        Text = " sijt "
+                    },
+                    new TextElement()
+                    {
+                        Style = TextStyle.Default.Size(32).BackgroundColor(Placeholders.BackgroundColor()),
+                        Text = " amet"
+                    }
+                };
+            }
+
+            Func<List<TextElement>> Source = () => Split(RandomText());
+
+            container
+                .Padding(50)
+                .Box().Border(1).Stack(stack =>
+                    {
+                        stack
+                            .Element()
+                            .Box()
+                            //.Background(Placeholders.BackgroundColor())
+                            .Element(new TextRun()
+                            {
+                                Elements = Lorem()
+                            });
+
+                        stack
+                            .Element()
+                            .Box()
+                            //.Background(Placeholders.BackgroundColor())
+                            .Element(new TextRun()
+                            {
+                                Elements = Source()
+                            });
+
+                        stack
+                            .Element()
+                            .Box()
+                            //.Background(Placeholders.BackgroundColor())
+                            .Element(new TextRun()
+                            {
+                                Elements = Source()
+                            });
+
+                        stack
+                            .Element()
+                            .Box()
+                            //.Background(Placeholders.BackgroundColor())
+                            .Element(new TextRun()
+                            {
+                                Elements = Source()
+                            });
+
+                        stack
+                            .Element()
+                            .Box()
+                            //.Background(Placeholders.BackgroundColor())
+                            .Element(new TextRun()
+                            {
+                                Elements = Source()
+                            });
+
+                        stack
+                            .Element()
+                            .Box()
+                            //.Background(Placeholders.BackgroundColor())
+                            .Element(new TextRun()
+                            {
+                                Elements = Source()
+                            });
+                    });
+        }
+
+        List<TextElement> RandomText()
+        {
+            var sizes = new[] { 24, 32, 48, 64};
+            
+            return Placeholders
+                .Sentence()
+                .Split(" ")
+                .Select(x => new TextElement
+                {
+                    Text = $"{x} ",
+                    Style = TextStyle
+                        .Default
+                        //.Size(sizes[Placeholders.Random.Next(0, 3)])
+                        .Size(24)
+                        .BackgroundColor(Placeholders.BackgroundColor())
+                        //.LineHeight((float)Placeholders.Random.NextDouble() / 2 + 1f)
+                        .LineHeight(1.2f)
+                })
+                .ToList();
+        }
+        
+        List<TextElement> Split(List<TextElement> elements)
+        {
+            return elements
+                .SelectMany(x => x
+                    .Text
+                    .Select(y => new TextElement
+                    {
+                        Style = x.Style,
+                        Text = y.ToString()
+                    }))
+                .ToList();
+        }
+    }
+}

QuestPDF.ReportSample/DataSource.cs

@@ -7,6 +7,9 @@ namespace QuestPDF.ReportSample
 {
     public static class DataSource
     {
+        public static int SectionCounter { get; set; }
+        public static int FieldCounter { get; set; }
+        
         public static ReportModel GetReport()
         {
             return new ReportModel
@@ -15,8 +18,8 @@ namespace QuestPDF.ReportSample
                 HeaderFields = HeaderFields(),
                 
                 LogoData = Helpers.GetImage("Logo.png"),
-                Sections = Enumerable.Range(0, 40).Select(x => GenerateSection()).ToList(),
-                Photos = Enumerable.Range(0, 25).Select(x => GetReportPhotos()).ToList()
+                Sections = Enumerable.Range(0, 50).Select(x => GenerateSection()).ToList(),
+                Photos = Enumerable.Range(0, 30).Select(x => GetReportPhotos()).ToList()
             };
 
             List<ReportHeaderField> HeaderFields()
@@ -86,6 +89,7 @@ namespace QuestPDF.ReportSample
                 return new ReportSectionMap
                 {
                     Label = "Location",
+                    ImageSource = Placeholders.Image,
                     Location = Helpers.RandomLocation()
                 };
             }
@@ -95,7 +99,10 @@ namespace QuestPDF.ReportSample
                 return new ReportSectionPhotos
                 {    
                     Label = "Photos",
-                    PhotoCount = Helpers.Random.Next(1, 15)
+                    Photos = Enumerable
+                        .Range(0, Helpers.Random.Next(1, 15))
+                        .Select(x => Placeholders.Image(400, 300))
+                        .ToList()
                 };
             }
 
@@ -103,9 +110,14 @@ namespace QuestPDF.ReportSample
             {
                 return new ReportPhoto()
                 {
+                    PhotoData = Placeholders.Image(800, 600),
+
                     Comments = Placeholders.Sentence(),
                     Date = DateTime.Now - TimeSpan.FromDays(Helpers.Random.NextDouble() * 100),
-                    Location = Helpers.RandomLocation()
+                    Location = Helpers.RandomLocation(),
+
+                    MapContextSource = x => Placeholders.Image(400, 300),
+                    MapDetailsSource = x => Placeholders.Image(400, 300)
                 };
             }
         }

QuestPDF.ReportSample/Helpers.cs

@@ -0,0 +1,28 @@
+using System;
+using System.IO;
+using SkiaSharp;
+
+namespace QuestPDF.ReportSample
+{
+    public static class Helpers
+    {
+        public static Random Random { get; } = new Random();
+        
+        public static string GetTestItem(string path) => Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Resources", path);
+
+        public static byte[] GetImage(string name)
+        {
+            var photoPath = GetTestItem(name);
+            return SKImage.FromEncodedData(photoPath).EncodedData.ToArray();
+        }
+
+        public static Location RandomLocation()
+        {
+            return new Location
+            {
+                Longitude = Helpers.Random.NextDouble() * 360f - 180f,
+                Latitude = Helpers.Random.NextDouble() * 180f - 90f
+            };
+        }
+    }
+}

QuestPDF.ReportSample/Layouts/ImageTemplate.cs

@@ -0,0 +1,31 @@
+using System;
+using QuestPDF.Fluent;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.ReportSample.Layouts
+{
+    public class ImageTemplate : IComponent
+    {
+        private Func<Size, byte[]> Source { get; }
+        private float AspectRatio { get; }
+
+        public ImageTemplate(byte[] source, float aspectRatio = 1.333333f) : this(_ => source, aspectRatio)
+        {
+            
+        }
+        
+        public ImageTemplate(Func<Size, byte[]> source, float aspectRatio = 1.333333f)
+        {
+            Source = source;
+            AspectRatio = aspectRatio;
+        }
+
+        public void Compose(IContainer container)
+        {
+            container
+                .AspectRatio(AspectRatio)
+                .Background("#EEEEEE")
+                .Image(Source(Size.Zero));
+        }
+    }
+}

QuestPDF.ReportSample/Layouts/PhotoTemplate.cs

@@ -1,4 +1,3 @@
-using System;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
@@ -18,11 +17,11 @@ namespace QuestPDF.ReportSample.Layouts
         {
             container
                 .ShowEntire()
-                .Column(column =>
+                .Stack(stack =>
                 {
-                    column.Spacing(5);
-                    column.Item().Element(PhotoWithMaps);
-                    column.Item().Element(PhotoDetails);
+                    stack.Spacing(5);
+                    stack.Item().Element(PhotoWithMaps);
+                    stack.Item().Element(PhotoDetails);
                 });
         }
         
@@ -31,14 +30,14 @@ namespace QuestPDF.ReportSample.Layouts
             container
                 .Row(row =>
                 {
-                    row.RelativeItem(2).AspectRatio(4 / 3f).Component<ImagePlaceholder>();
+                    row.RelativeColumn(2).AspectRatio(4 / 3f).Image(Placeholders.Image);
 
-                    row.RelativeItem().PaddingLeft(5).Column(column =>
+                    row.RelativeColumn().PaddingLeft(5).Stack(stack =>
                     {
-                        column.Spacing(7f);
+                        stack.Spacing(7f);
                         
-                        column.Item().AspectRatio(4 / 3f).Component<ImagePlaceholder>();
-                        column.Item().AspectRatio(4 / 3f).Component<ImagePlaceholder>();
+                        stack.Item().AspectRatio(4 / 3f).Image(Placeholders.Image);
+                        stack.Item().AspectRatio(4 / 3f).Image(Placeholders.Image);
                     });
                 });
         }
@@ -48,14 +47,14 @@ namespace QuestPDF.ReportSample.Layouts
             container.Border(0.75f).BorderColor(Colors.Grey.Medium).Grid(grid =>
             {
                 grid.Columns(6);
-
-                grid.Item().LabelCell().Text("Date");
-                grid.Item(2).ValueCell().Text(Model.Date?.ToString("g") ?? string.Empty);
-                grid.Item().LabelCell().Text("Location");
-                grid.Item(2).ValueCell().Text(Model.Location.Format());
                 
-                grid.Item().LabelCell().Text("Comments");
-                grid.Item(5).ValueCell().Text(Model.Comments);
+                grid.Item().LabelCell().Text("Date", Typography.Normal);
+                grid.Item(2).ValueCell().Text(Model.Date?.ToString("g") ?? string.Empty, Typography.Normal);
+                grid.Item().LabelCell().Text("Location", Typography.Normal);
+                grid.Item(2).ValueCell().Text(Model.Location.Format(), Typography.Normal);
+                
+                grid.Item().LabelCell().Text("Comments", Typography.Normal);
+                grid.Item(5).ValueCell().Text(Model.Comments, Typography.Normal);
             });
         }
     }

QuestPDF.ReportSample/Layouts/SectionTemplate.cs

@@ -1,4 +1,3 @@
-using System.Linq;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
@@ -21,26 +20,25 @@ namespace QuestPDF.ReportSample.Layouts
                 .Decoration(decoration =>
                 {
                     decoration
-                        .Before()
+                        .Header()
                         .PaddingBottom(5)
-                        .Text(Model.Title)
-                        .Style(Typography.Headline);
+                        .Text(Model.Title, Typography.Headline);
 
-                    decoration.Content().Border(0.75f).BorderColor(Colors.Grey.Medium).Column(column =>
+                    decoration.Content().Border(0.75f).BorderColor(Colors.Grey.Medium).Stack(stack =>
                     {
                         foreach (var part in Model.Parts)
                         {
-                            column.Item().EnsureSpace(25).Row(row =>
+                            stack.Item().Row(row =>
                             {
-                                row.ConstantItem(150).LabelCell().Text(part.Label);
-                                var frame = row.RelativeItem().ValueCell();
+                                row.ConstantColumn(150).LabelCell().Text(part.Label, Typography.Normal);
+                                var frame = row.RelativeColumn().ValueCell();
                             
                                 if (part is ReportSectionText text)
-                                    frame.ShowEntire().Text(text.Text);
-                                
+                                    frame.Text(text.Text, Typography.Normal);
+                        
                                 if (part is ReportSectionMap map)
                                     frame.Element(x => MapElement(x, map));
-                                
+                        
                                 if (part is ReportSectionPhotos photos)
                                     frame.Element(x => PhotosElement(x, photos));
                             });
@@ -51,38 +49,35 @@ namespace QuestPDF.ReportSample.Layouts
         
         void MapElement(IContainer container, ReportSectionMap model)
         {
-            if (model.Location == null)
+            if (model.ImageSource == null || model.Location == null)
             {
-                container.Text("No location provided");
+                container.Text("No location provided", Typography.Normal);
                 return;
             }
 
-            container.ShowEntire().Column(column =>
+            container.ShowEntire().Stack(stack =>
             {
-                column.Spacing(5);
+                stack.Spacing(5);
                 
-                column.Item().MaxWidth(250).AspectRatio(4 / 3f).Component<ImagePlaceholder>();
-                column.Item().Text(model.Location.Format());
+                stack.Item().MaxWidth(250).AspectRatio(4 / 3f).Image(Placeholders.Image);
+                stack.Item().Text(model.Location.Format(), Typography.Normal);
             });
         }
         
         void PhotosElement(IContainer container, ReportSectionPhotos model)
         {
-            if (model.PhotoCount == 0)
+            if (model.Photos.Count == 0)
             {
-                container.Text("No photos").Style(Typography.Normal);
+                container.Text("No photos", Typography.Normal);
                 return;
             }
 
-            container.DebugArea("Photos").Grid(grid =>
+            container.Debug("Photos").Grid(grid =>
             {
                 grid.Spacing(5);
                 grid.Columns(3);
                 
-                Enumerable
-                    .Range(0, model.PhotoCount)
-                    .ToList()
-                    .ForEach(x => grid.Item().AspectRatio(4 / 3f).Component<ImagePlaceholder>());
+                model.Photos.ForEach(x => grid.Item().AspectRatio(4 / 3f).Image(Placeholders.Image));
             });
         }
     }

QuestPDF.ReportSample/Layouts/StandardReport.cs

@@ -0,0 +1,89 @@
+using QuestPDF.Drawing;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.ReportSample.Layouts
+{
+    public class StandardReport : IDocument
+    {
+        private ReportModel Model { get; }
+
+        public StandardReport(ReportModel model)
+        {
+            Model = model;
+        }
+        
+        public DocumentMetadata GetMetadata()
+        {
+            return new DocumentMetadata()
+            {
+                Title = Model.Title,
+                Size = PageSizes.A4
+            };
+        }
+
+        public void Compose(IContainer container)
+        {
+            container
+                .PaddingVertical(40)
+                .PaddingHorizontal(50)
+                .Page(page =>
+                {
+                    page.Header().Element(ComposeHeader);
+                    page.Content().Element(ComposeContent);
+                    page.Footer().AlignCenter().PageNumber("Page {number}");
+                });
+        }
+
+        private void ComposeHeader(IContainer container)
+        {
+            container.Stack(stack =>
+            {
+                stack.Item().Row(row =>
+                {
+                    row.Spacing(50);
+                    
+                    row.RelativeColumn().PaddingTop(-10).Text(Model.Title, Typography.Title);
+                    row.ConstantColumn(150).ExternalLink("https://www.questpdf.com").Image(Model.LogoData);
+                });
+
+                stack.Item().ShowOnce().PaddingVertical(15).Border(1f).BorderColor(Colors.Grey.Lighten1).ExtendHorizontal();
+                
+                stack.Item().ShowOnce().Grid(grid =>
+                {
+                    grid.Columns(2);
+                    grid.Spacing(5);
+                        
+                    foreach (var field in Model.HeaderFields)
+                    {
+                        grid.Item().Stack(row =>
+                        {   
+                            row.Item().AlignLeft().Text(field.Label, Typography.Normal.SemiBold());
+                            row.Item().Text(field.Value, Typography.Normal);
+                        });
+                    }
+                });
+            });
+        }
+
+        void ComposeContent(IContainer container)
+        {
+            container.PaddingVertical(20).Stack(stack =>
+            {
+                stack.Spacing(20);
+
+                stack.Item().Component(new TableOfContentsTemplate(Model.Sections));
+                
+                foreach (var section in Model.Sections)
+                    stack.Item().Location(section.Title).Component(new SectionTemplate(section));
+
+                stack.Item().PageBreak();
+                stack.Item().Location("Photos");
+                
+                foreach (var photo in Model.Photos)
+                    stack.Item().Component(new PhotoTemplate(photo));
+            });
+        }
+    }
+}

QuestPDF.ReportSample/Layouts/TableOfContentsTemplate.cs

@@ -0,0 +1,49 @@
+using System.Collections.Generic;
+using QuestPDF.Fluent;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.ReportSample.Layouts
+{
+    public class TableOfContentsTemplate : IComponent
+    {
+        private List<ReportSection> Sections { get; }
+
+        public TableOfContentsTemplate(List<ReportSection> sections)
+        {
+            Sections = sections;
+        }
+        
+        public void Compose(IContainer container)
+        {
+            container
+                .Decoration(decoration =>
+                {
+                    decoration
+                        .Header()
+                        .PaddingBottom(5)
+                        .Text("Table of contents", Typography.Headline);
+
+                    decoration.Content().Stack(stack =>
+                    {
+                        stack.Spacing(5);
+                        
+                        for (var i = 0; i < Sections.Count; i++)
+                            stack.Item().Element(c => DrawLink(c, i+1, Sections[i].Title));
+
+                        stack.Item().Element(c => DrawLink(c, Sections.Count+1, "Photos"));
+                    });
+                });
+        }
+
+        private void DrawLink(IContainer container, int number, string locationName)
+        {
+            container
+                .InternalLink(locationName)
+                .Row(row =>
+                {
+                    row.ConstantColumn(25).Text($"{number}.", Typography.Normal);
+                    row.RelativeColumn().Text(locationName, Typography.Normal);
+                });
+        }
+    }
+}

QuestPDF.ReportSample/Models.cs

@@ -44,16 +44,22 @@ namespace QuestPDF.ReportSample
     
     public class ReportSectionMap : ReportSectionElement
     {
+        public Func<Size, byte[]> ImageSource { get; set; }
         public Location Location { get; set; }
     }
 
     public class ReportSectionPhotos : ReportSectionElement
     {
-        public int PhotoCount { get; set; }
+        public List<byte[]> Photos { get; set; }
     }
 
     public class ReportPhoto
-    {
+    { 
+        public byte[] PhotoData { get; set; }
+        
+        public Func<Size, byte[]> MapDetailsSource { get; set; }
+        public Func<Size, byte[]> MapContextSource { get; set; }
+        
         public Location Location { get; set; }
         
         public DateTime? Date { get; set; }

QuestPDF.ReportSample/QuestPDF.ReportSample.csproj

@@ -1,18 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net6.0</TargetFramework>
+        <TargetFramework>netcoreapp3.1</TargetFramework>
         <IsPackable>false</IsPackable>
         <LangVersion>8</LangVersion>
         <RootNamespace>QuestPDF.ReportSample</RootNamespace>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
-        <PackageReference Include="nunit" Version="3.13.2" />
-        <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
-        <PackageReference Include="SkiaSharp" Version="2.88.3" />
+        <PackageReference Include="DeepCloner" Version="0.10.2" />
+        <PackageReference Include="nunit" Version="3.12.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" />
     </ItemGroup>
 
     <ItemGroup>

QuestPDF.ReportSample/Tests.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using NUnit.Framework;
+using QuestPDF.Fluent;
+using QuestPDF.ReportSample.Layouts;
+
+namespace QuestPDF.ReportSample
+{
+    public class ReportGeneration
+    {
+        [Test] 
+        public void GenerateAndShow()
+        {
+            var reportModel = DataSource.GetReport();
+            var report = new StandardReport(reportModel);
+            
+            var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"test_result.pdf");
+            report.GeneratePdf(path);
+            
+            Process.Start("explorer.exe", path);
+        }
+
+        [Test] 
+        public void PerformanceBenchmark()
+        {
+            // target document length should be around 100 pages
+            
+            // test size
+            const int testSize = 100;
+            const decimal performanceTarget = 1; // documents per second
+
+            // create report models
+            var reports = Enumerable
+                .Range(0, testSize)
+                .Select(x =>
+                {
+                    var reportModel = DataSource.GetReport();
+                    return new StandardReport(reportModel);
+                })
+                .ToList();
+
+            // generate documents
+            var sw = new Stopwatch();
+            
+            sw.Start();
+            var totalSize = reports.Select(x => x.GeneratePdf()).Sum(x => (long)x.Length);
+            sw.Stop();
+
+            // show summary
+            Console.WriteLine($"Total size: {totalSize:N0} bytes");
+            
+            var performance = sw.ElapsedMilliseconds / (decimal)testSize;
+            var speed = 1000M / performance;
+            Console.WriteLine($"Test time: {sw.ElapsedMilliseconds} ms");
+            Console.WriteLine($"Time per document: {performance:N} ms");
+            Console.WriteLine($"Documents per second: {speed:N} d/s");
+
+            if (speed < performanceTarget)
+                throw new Exception("Rendering algorithm is too slow.");
+        }
+    }
+}

QuestPDF.ReportSample/Typography.cs

@@ -6,8 +6,8 @@ namespace QuestPDF.ReportSample
 {
     public static class Typography
     {
-        public static TextStyle Title => TextStyle.Default.FontFamily(Fonts.Lato).FontColor(Colors.Blue.Darken3).FontSize(26).Black();
-        public static TextStyle Headline => TextStyle.Default.FontFamily(Fonts.Lato).FontColor(Colors.Blue.Medium).FontSize(16).SemiBold();
-        public static TextStyle Normal => TextStyle.Default.FontFamily(Fonts.Lato).FontColor(Colors.Black).FontSize(10).LineHeight(1.2f);
+        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();
     }
-}
+}

QuestPDF.UnitTests/AlignmentTests.cs

@@ -1,5 +1,5 @@
 using NUnit.Framework;
-using QuestPDF.Drawing;
+using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
@@ -10,7 +10,11 @@ namespace QuestPDF.UnitTests
     public class AlignmentTests
     {
         [Test]
-        public void Measure() => SimpleContainerTests.Measure<Alignment>();
+        public void Measure_ShouldHandleNullChild() => new Alignment().MeasureWithoutChild();
+        
+        [Test]
+        public void Draw_ShouldHandleNullChild() => new Alignment().DrawWithoutChild();
+
         [Test]
         public void Draw_HorizontalCenter_VerticalCenter()
         {
@@ -23,7 +27,7 @@ namespace QuestPDF.UnitTests
                     Child = x.CreateChild()
                 })
                 .DrawElement(new Size(1000, 500))
-                .ExpectChildMeasure(expectedInput: new Size(1000, 500), returns: SpacePlan.PartialRender(new Size(400, 200)))
+                .ExpectChildMeasure(expectedInput: new Size(1000, 500), returns: new PartialRender(new Size(400, 200)))
                 .ExpectCanvasTranslate(new Position(300, 150))
                 .ExpectChildDraw(new Size(400, 200))
                 .ExpectCanvasTranslate(new Position(-300, -150))
@@ -42,7 +46,7 @@ namespace QuestPDF.UnitTests
                     Child = x.CreateChild()
                 })
                 .DrawElement(new Size(400, 300))
-                .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: SpacePlan.FullRender(new Size(100, 50)))
+                .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: new FullRender(new Size(100, 50)))
                 .ExpectCanvasTranslate(new Position(0, 125))
                 .ExpectChildDraw(new Size(100, 50))
                 .ExpectCanvasTranslate(new Position(0, -125))
@@ -61,7 +65,7 @@ namespace QuestPDF.UnitTests
                     Child = x.CreateChild()
                 })
                 .DrawElement(new Size(400, 300))
-                .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: SpacePlan.FullRender(new Size(100, 50)))
+                .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: new FullRender(new Size(100, 50)))
                 .ExpectCanvasTranslate(new Position(150, 250))
                 .ExpectChildDraw(new Size(100, 50))
                 .ExpectCanvasTranslate(new Position(-150, -250))
@@ -80,49 +84,11 @@ namespace QuestPDF.UnitTests
                     Child = x.CreateChild()
                 })
                 .DrawElement(new Size(400, 300))
-                .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: SpacePlan.FullRender(new Size(100, 50)))
+                .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: new FullRender(new Size(100, 50)))
                 .ExpectCanvasTranslate(new Position(300, 0))
                 .ExpectChildDraw(new Size(100, 50))
                 .ExpectCanvasTranslate(new Position(-300, 0))
                 .CheckDrawResult();
         }
-        
-        [Test]
-        public void Draw_HorizontalCenter_VerticalNone()
-        {
-            TestPlan
-                .For(x => new Alignment
-                {
-                    Horizontal = HorizontalAlignment.Center,
-                    Vertical = null,
-                    
-                    Child = x.CreateChild()
-                })
-                .DrawElement(new Size(400, 300))
-                .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: SpacePlan.FullRender(new Size(100, 50)))
-                .ExpectCanvasTranslate(new Position(150, 0))
-                .ExpectChildDraw(new Size(100, 300))
-                .ExpectCanvasTranslate(new Position(-150, 0))
-                .CheckDrawResult();
-        }
-        
-        [Test]
-        public void Draw_HorizontalNone_VerticalMiddle()
-        {
-            TestPlan
-                .For(x => new Alignment
-                {
-                    Horizontal = null,
-                    Vertical = VerticalAlignment.Middle,
-                    
-                    Child = x.CreateChild()
-                })
-                .DrawElement(new Size(400, 300))
-                .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: SpacePlan.FullRender(new Size(100, 50)))
-                .ExpectCanvasTranslate(new Position(0, 125))
-                .ExpectChildDraw(new Size(400, 50))
-                .ExpectCanvasTranslate(new Position(0, -125))
-                .CheckDrawResult();
-        }
     }
 }

QuestPDF.UnitTests/AspectRatioTests.cs

@@ -1,5 +1,5 @@
 using NUnit.Framework;
-using QuestPDF.Drawing;
+using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
@@ -9,6 +9,12 @@ 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()
         {
@@ -20,8 +26,8 @@ namespace QuestPDF.UnitTests
                     Ratio = 2f
                 })
                 .MeasureElement(new Size(400, 201))
-                .ExpectChildMeasure(new Size(400, 200), SpacePlan.FullRender(100, 50))
-                .CheckMeasureResult(SpacePlan.FullRender(400, 200));
+                .ExpectChildMeasure(new Size(400, 200), new FullRender(100, 50))
+                .CheckMeasureResult(new FullRender(400, 200));
         }
         
         [Test]
@@ -35,8 +41,8 @@ namespace QuestPDF.UnitTests
                     Ratio = 2f
                 })
                 .MeasureElement(new Size(400, 201))
-                .ExpectChildMeasure(new Size(400, 200), SpacePlan.PartialRender(100, 50))
-                .CheckMeasureResult(SpacePlan.PartialRender(400, 200));
+                .ExpectChildMeasure(new Size(400, 200), new PartialRender(100, 50))
+                .CheckMeasureResult(new PartialRender(400, 200));
         }
         
         [Test]
@@ -50,8 +56,8 @@ namespace QuestPDF.UnitTests
                     Ratio = 2f
                 })
                 .MeasureElement(new Size(400, 201))
-                .ExpectChildMeasure(new Size(400, 200), SpacePlan.Wrap())
-                .CheckMeasureResult(SpacePlan.Wrap());
+                .ExpectChildMeasure(new Size(400, 200), new Wrap())
+                .CheckMeasureResult(new Wrap());
         }
         
         [Test]
@@ -65,8 +71,8 @@ namespace QuestPDF.UnitTests
                     Ratio = 2f
                 })
                 .MeasureElement(new Size(400, 201))
-                .ExpectChildMeasure(new Size(400, 200), SpacePlan.FullRender(100, 50))
-                .CheckMeasureResult(SpacePlan.FullRender(400, 200));
+                .ExpectChildMeasure(new Size(400, 200), new FullRender(100, 50))
+                .CheckMeasureResult(new FullRender(400, 200));
         }
 
         [Test]
@@ -80,7 +86,7 @@ namespace QuestPDF.UnitTests
                     Ratio = 2f
                 })
                 .MeasureElement(new Size(400, 199))
-                .CheckMeasureResult(SpacePlan.Wrap());
+                .CheckMeasureResult(new Wrap());
         }
         
         [Test]
@@ -94,8 +100,8 @@ namespace QuestPDF.UnitTests
                     Ratio = 2f
                 })
                 .MeasureElement(new Size(401, 200))
-                .ExpectChildMeasure(new Size(400, 200), SpacePlan.FullRender(100, 50))
-                .CheckMeasureResult(SpacePlan.FullRender(400, 200));
+                .ExpectChildMeasure(new Size(400, 200), new FullRender(100, 50))
+                .CheckMeasureResult(new FullRender(400, 200));
         }
         
         [Test]
@@ -109,7 +115,7 @@ namespace QuestPDF.UnitTests
                     Ratio = 2f
                 })
                 .MeasureElement(new Size(399, 200))
-                .CheckMeasureResult(SpacePlan.Wrap());
+                .CheckMeasureResult(new Wrap());
         }
         
         [Test]
@@ -123,8 +129,8 @@ namespace QuestPDF.UnitTests
                     Ratio = 2f
                 })
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure(new Size(400, 200), SpacePlan.FullRender(100, 50))
-                .CheckMeasureResult(SpacePlan.FullRender(400, 200));
+                .ExpectChildMeasure(new Size(400, 200), new FullRender(100, 50))
+                .CheckMeasureResult(new FullRender(400, 200));
         }
         
         [Test]
@@ -138,8 +144,8 @@ namespace QuestPDF.UnitTests
                     Ratio = 2f
                 })
                 .MeasureElement(new Size(500, 200))
-                .ExpectChildMeasure(new Size(400, 200), SpacePlan.FullRender(100, 50))
-                .CheckMeasureResult(SpacePlan.FullRender(400, 200));
+                .ExpectChildMeasure(new Size(400, 200), new FullRender(100, 50))
+                .CheckMeasureResult(new FullRender(400, 200));
         }
         
         [Test]
@@ -153,9 +159,7 @@ namespace QuestPDF.UnitTests
                     Ratio = 2f
                 })
                 .DrawElement(new Size(500, 200))
-                .ExpectCanvasTranslate(0, 0)
                 .ExpectChildDraw(new Size(400, 200))
-                .ExpectCanvasTranslate(0, 0)
                 .CheckDrawResult();
         }
         
@@ -170,45 +174,7 @@ namespace QuestPDF.UnitTests
                     Ratio = 2f
                 })
                 .DrawElement(new Size(400, 300))
-                .ExpectCanvasTranslate(0, 0)
                 .ExpectChildDraw(new Size(400, 200))
-                .ExpectCanvasTranslate(0, 0)
-                .CheckDrawResult();
-        } 
-        
-        [Test]
-        public void DrawChild_PerWidth_RightToLeft()
-        {
-            TestPlan
-                .For(x => new AspectRatio
-                {
-                    Child = x.CreateChild(),
-                    Option = AspectRatioOption.FitArea,
-                    Ratio = 2f,
-                    ContentDirection = ContentDirection.RightToLeft
-                })
-                .DrawElement(new Size(500, 200))
-                .ExpectCanvasTranslate(100, 0)
-                .ExpectChildDraw(new Size(400, 200))
-                .ExpectCanvasTranslate(-100, 0)
-                .CheckDrawResult();
-        }
-        
-        [Test]
-        public void DrawChild_PerHeight_RightToLeft()
-        {
-            TestPlan
-                .For(x => new AspectRatio
-                {
-                    Child = x.CreateChild(),
-                    Option = AspectRatioOption.FitArea,
-                    Ratio = 2f,
-                    ContentDirection = ContentDirection.RightToLeft
-                })
-                .DrawElement(new Size(400, 300))
-                .ExpectCanvasTranslate(0, 0)
-                .ExpectChildDraw(new Size(400, 200))
-                .ExpectCanvasTranslate(0, 0)
                 .CheckDrawResult();
         } 
     }

QuestPDF.UnitTests/BackgroundTests.cs

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

QuestPDF.UnitTests/BorderTests.cs

@@ -1,5 +1,5 @@
 using NUnit.Framework;
-using QuestPDF.Drawing;
+using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
 using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
@@ -11,8 +11,8 @@ namespace QuestPDF.UnitTests
     public class BorderTests
     {
         [Test]
-        public void Measure() => SimpleContainerTests.Measure<Border>();
-        
+        public void Measure_ShouldHandleNullChild() => new Border().MeasureWithoutChild();
+
         [Test]
         public void ComponentShouldNotAffectLayout()
         {
@@ -27,8 +27,8 @@ namespace QuestPDF.UnitTests
                     Child = x.CreateChild()
                 })
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: SpacePlan.FullRender(new Size(100, 50)))
-                .CheckMeasureResult( SpacePlan.FullRender(new Size(100, 50)));
+                .ExpectChildMeasure(expectedInput: new Size(400, 300), returns: new FullRender(new Size(100, 50)))
+                .CheckMeasureResult( new FullRender(new Size(100, 50)));
         }
         
         [Test]

QuestPDF.UnitTests/ConstrainedTests.cs

@@ -0,0 +1,98 @@
+using NUnit.Framework;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+using QuestPDF.UnitTests.TestEngine;
+
+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()
+        {
+            TestPlan
+                .For(x => new Constrained
+                {
+                    MinHeight = 100
+                })
+                .MeasureElement(new Size(400, 50))
+                .CheckMeasureResult(new Wrap());
+        }
+        
+        [Test]
+        public void Measure_MinHeight_ExtendHeight()
+        {
+            TestPlan
+                .For(x => new Constrained
+                {
+                    MinHeight = 100,
+                    Child = x.CreateChild()
+                })
+                .MeasureElement(new Size(400, 200))
+                .ExpectChildMeasure(new Size(400, 200), new FullRender(400, 50))
+                .CheckMeasureResult(new FullRender(400, 100));
+        }
+        
+        [Test]
+        public void Measure_MinHeight_PassHeight()
+        {
+            TestPlan
+                .For(x => new Constrained
+                {
+                    MinHeight = 100,
+                    Child = x.CreateChild()
+                })
+                .MeasureElement(new Size(400, 200))
+                .ExpectChildMeasure(new Size(400, 200), new FullRender(400, 150))
+                .CheckMeasureResult(new FullRender(400, 150));
+        }
+        
+        [Test]
+        public void Measure_MaxHeight_Empty()
+        {
+            TestPlan
+                .For(x => new Constrained
+                {
+                    MaxHeight = 100
+                })
+                .MeasureElement(new Size(400, 150))
+                .CheckMeasureResult(new FullRender(0, 0));
+        }
+        
+        [Test]
+        public void Measure_MaxHeight_PartialRender()
+        {
+            TestPlan
+                .For(x => new Constrained
+                {
+                    MaxHeight = 100,
+                    Child = x.CreateChild()
+                })
+                .MeasureElement(new Size(400, 200))
+                .ExpectChildMeasure(new Size(400, 100), new PartialRender(400, 75))
+                .CheckMeasureResult(new PartialRender(400, 75));
+        }
+        
+        [Test]
+        public void Measure_MaxHeight_ExpectWrap()
+        {
+            TestPlan
+                .For(x => new Constrained
+                {
+                    MaxHeight = 100,
+                    Child = x.CreateChild()
+                })
+                .MeasureElement(new Size(400, 200))
+                .ExpectChildMeasure(new Size(400, 100), new Wrap())
+                .CheckMeasureResult(new Wrap());
+        }
+    }
+}

QuestPDF.UnitTests/DebugTests.cs

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

QuestPDF.UnitTests/DecorationTests.cs

@@ -0,0 +1,136 @@
+using NUnit.Framework;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+using QuestPDF.UnitTests.TestEngine;
+
+namespace QuestPDF.UnitTests
+{
+    [TestFixture]
+    public class DecorationTests
+    {
+        #region Measure
+
+        [Test]
+        public void Measure_ReturnsWrap_WhenDecorationReturnsWrap()
+        {
+            TestPlan
+                .For(x => new SimpleDecoration
+                {
+                    Type = DecorationType.Append,
+                    DecorationElement = x.CreateChild("decoration"),
+                    ContentElement = x.CreateChild("content")
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure("decoration", new Size(400, 300), new Wrap())
+                .CheckMeasureResult(new Wrap());
+        }
+        
+        [Test]
+        public void Measure_ReturnsWrap_WhenDecorationReturnsPartialRender()
+        {
+            TestPlan
+                .For(x => new SimpleDecoration
+                {
+                    Type = DecorationType.Append,
+                    DecorationElement = x.CreateChild("decoration"),
+                    ContentElement = x.CreateChild("content")
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure("decoration", new Size(400, 300), new PartialRender(300, 200))
+                .CheckMeasureResult(new Wrap());
+        }
+        
+        [Test]
+        public void Measure_ReturnsWrap_WhenContentReturnsWrap()
+        {
+            TestPlan
+                .For(x => new SimpleDecoration
+                {
+                    Type = DecorationType.Append,
+                    DecorationElement = x.CreateChild("decoration"),
+                    ContentElement = x.CreateChild("content")
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure("decoration", new Size(400, 300), new FullRender(300, 100))
+                .ExpectChildMeasure("content", new Size(400, 200), new Wrap())
+                .CheckMeasureResult(new Wrap());
+        }
+        
+        [Test]
+        public void Measure_ReturnsPartialRender_WhenContentReturnsPartialRender()
+        {
+            TestPlan
+                .For(x => new SimpleDecoration
+                {
+                    Type = DecorationType.Append,
+                    DecorationElement = x.CreateChild("decoration"),
+                    ContentElement = x.CreateChild("content")
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure("decoration", new Size(400, 300), new FullRender(300, 100))
+                .ExpectChildMeasure("content", new Size(400, 200), new PartialRender(200, 150))
+                .CheckMeasureResult(new PartialRender(400, 250));
+        }
+        
+        [Test]
+        public void Measure_ReturnsFullRender_WhenContentReturnsFullRender()
+        {
+            TestPlan
+                .For(x => new SimpleDecoration
+                {
+                    Type = DecorationType.Append,
+                    DecorationElement = x.CreateChild("decoration"),
+                    ContentElement = x.CreateChild("content")
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure("decoration", new Size(400, 300), new FullRender(300, 100))
+                .ExpectChildMeasure("content", new Size(400, 200), new FullRender(200, 150))
+                .CheckMeasureResult(new FullRender(400, 250));
+        }
+        
+        #endregion
+        
+        #region Draw
+        
+        [Test]
+        public void Draw_Prepend()
+        {
+            TestPlan
+                .For(x => new SimpleDecoration
+                {
+                    Type = DecorationType.Prepend,
+                    DecorationElement = x.CreateChild("decoration"),
+                    ContentElement = x.CreateChild("content")
+                })
+                .DrawElement(new Size(400, 300))
+                .ExpectChildMeasure("decoration", new Size(400, 300), new FullRender(300, 100))
+                .ExpectChildDraw("decoration", new Size(400, 100))
+                .ExpectCanvasTranslate(0, 100)
+                .ExpectChildDraw("content", new Size(400, 200))
+                .ExpectCanvasTranslate(0, -100)
+                .CheckDrawResult();
+        }
+        
+        [Test]
+        public void Draw_Append()
+        {
+            TestPlan
+                .For(x => new SimpleDecoration
+                {
+                    Type = DecorationType.Append,
+                    DecorationElement = x.CreateChild("decoration"),
+                    ContentElement = x.CreateChild("content")
+                })
+                .DrawElement(new Size(400, 300))
+                .ExpectChildMeasure("decoration", new Size(400, 300), new FullRender(300, 100))
+                .ExpectChildDraw("content", new Size(400, 200))
+                .ExpectCanvasTranslate(0, 200)
+                .ExpectChildDraw("decoration", new Size(400, 100))
+                .ExpectCanvasTranslate(0, -200)
+                .CheckDrawResult();
+        }
+
+        #endregion
+    }
+}

QuestPDF.UnitTests/DynamicImageTests.cs

@@ -1,6 +1,6 @@
 using FluentAssertions;
 using NUnit.Framework;
-using QuestPDF.Drawing;
+using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
@@ -17,12 +17,10 @@ namespace QuestPDF.UnitTests
             TestPlan
                 .For(x => new DynamicImage
                 {
-                    TargetDpi = DocumentSettings.DefaultRasterDpi,
-                    CompressionQuality = ImageCompressionQuality.High,
                     Source = GenerateImage
                 })
                 .MeasureElement(new Size(300, 200))
-                .CheckMeasureResult(SpacePlan.FullRender(300, 200));
+                .CheckMeasureResult(new FullRender(300, 200));
         }
         
         [Test]
@@ -31,8 +29,6 @@ namespace QuestPDF.UnitTests
             TestPlan
                 .For(x => new DynamicImage
                 {
-                    TargetDpi = DocumentSettings.DefaultRasterDpi,
-                    CompressionQuality = ImageCompressionQuality.High,
                     Source = size => null
                 })
                 .DrawElement(new Size(300, 200))
@@ -45,8 +41,6 @@ namespace QuestPDF.UnitTests
             TestPlan
                 .For(x => new DynamicImage
                 {
-                    TargetDpi = DocumentSettings.DefaultRasterDpi,
-                    CompressionQuality = ImageCompressionQuality.High,
                     Source = GenerateImage
                 })
                 .DrawElement(new Size(300, 200))
@@ -57,13 +51,11 @@ namespace QuestPDF.UnitTests
         [Test]
         public void Draw_PassesCorrectSizeToSource()
         {
-            ImageSize passedSize = default;
+            Size passedSize = null;
 
             TestPlan
                 .For(x => new DynamicImage
                 {
-                    TargetDpi = DocumentSettings.DefaultRasterDpi * 3,
-                    CompressionQuality = ImageCompressionQuality.High,
                     Source = size =>
                     {
                         passedSize = size;
@@ -74,13 +66,12 @@ namespace QuestPDF.UnitTests
                 .ExpectCanvasDrawImage(Position.Zero, new Size(400, 300))
                 .CheckDrawResult();
             
-            passedSize.Width.Should().Be(1200);
-            passedSize.Height.Should().Be(900);
+            passedSize.Should().Be(new Size(400, 300));
         }
         
-        byte[] GenerateImage(ImageSize size)
+        byte[] GenerateImage(Size size)
         {
-            var image = GenerateImage(size.Width, size.Height);
+            var image = GenerateImage((int) size.Width, (int) size.Height);
             return image.Encode(SKEncodedImageFormat.Png, 100).ToArray();
         }
         

QuestPDF.UnitTests/EnsureSpaceTests.cs

@@ -1,5 +1,5 @@
 using NUnit.Framework;
-using QuestPDF.Drawing;
+using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
@@ -19,8 +19,8 @@ namespace QuestPDF.UnitTests
                     MinHeight = 200
                 })
                 .MeasureElement(new Size(400, 100))
-                .ExpectChildMeasure(new Size(400, 100), SpacePlan.Wrap())
-                .CheckMeasureResult(SpacePlan.Wrap());
+                .ExpectChildMeasure(new Size(400, 100), new Wrap())
+                .CheckMeasureResult(new Wrap());
         }
         
         [Test]
@@ -33,8 +33,8 @@ namespace QuestPDF.UnitTests
                     MinHeight = 200
                 })
                 .MeasureElement(new Size(400, 100))
-                .ExpectChildMeasure(new Size(400, 100), SpacePlan.PartialRender(300, 50))
-                .CheckMeasureResult(SpacePlan.Wrap());
+                .ExpectChildMeasure(new Size(400, 100), new PartialRender(300, 50))
+                .CheckMeasureResult(new Wrap());
         }
         
         [Test]
@@ -47,8 +47,8 @@ namespace QuestPDF.UnitTests
                     MinHeight = 200
                 })
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure(new Size(400, 300), SpacePlan.PartialRender(300, 250))
-                .CheckMeasureResult(SpacePlan.PartialRender(300, 250));
+                .ExpectChildMeasure(new Size(400, 300), new PartialRender(300, 250))
+                .CheckMeasureResult(new PartialRender(300, 250));
         }
         
         [Test]
@@ -61,8 +61,8 @@ namespace QuestPDF.UnitTests
                     MinHeight = 200
                 })
                 .MeasureElement(new Size(400, 100))
-                .ExpectChildMeasure(new Size(400, 100), SpacePlan.FullRender(300, 50))
-                .CheckMeasureResult(SpacePlan.FullRender(300, 50));
+                .ExpectChildMeasure(new Size(400, 100), new FullRender(300, 50))
+                .CheckMeasureResult(new FullRender(300, 50));
         }
         
         [Test]
@@ -75,11 +75,8 @@ namespace QuestPDF.UnitTests
                     MinHeight = 200
                 })
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure(new Size(400, 300), SpacePlan.FullRender(300, 250))
-                .CheckMeasureResult(SpacePlan.FullRender(300, 250));
+                .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

@@ -1,5 +1,5 @@
 using NUnit.Framework;
-using QuestPDF.Drawing;
+using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
@@ -9,6 +9,12 @@ 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()
         {
@@ -18,8 +24,8 @@ namespace QuestPDF.UnitTests
                     Child = x.CreateChild()
                 })
                 .MeasureElement(new Size(400, 200))
-                .ExpectChildMeasure(new Size(400, 200), SpacePlan.Wrap())
-                .CheckMeasureResult(SpacePlan.Wrap());
+                .ExpectChildMeasure(new Size(400, 200), new Wrap())
+                .CheckMeasureResult(new Wrap());
         }
         
         [Test]
@@ -33,8 +39,8 @@ namespace QuestPDF.UnitTests
                     ExtendVertical = true
                 })
                 .MeasureElement(new Size(400, 200))
-                .ExpectChildMeasure(new Size(400, 200), SpacePlan.PartialRender(300, 100))
-                .CheckMeasureResult(SpacePlan.PartialRender(400, 200));
+                .ExpectChildMeasure(new Size(400, 200), new PartialRender(300, 100))
+                .CheckMeasureResult(new PartialRender(400, 200));
         }
         
         [Test]
@@ -48,8 +54,8 @@ namespace QuestPDF.UnitTests
                     ExtendVertical = true
                 })
                 .MeasureElement(new Size(400, 200))
-                .ExpectChildMeasure(new Size(400, 200), SpacePlan.FullRender(300, 100))
-                .CheckMeasureResult(SpacePlan.FullRender(400, 200));
+                .ExpectChildMeasure(new Size(400, 200), new FullRender(300, 100))
+                .CheckMeasureResult(new FullRender(400, 200));
         }
         
         [Test]
@@ -63,8 +69,8 @@ namespace QuestPDF.UnitTests
                     ExtendVertical = false
                 })
                 .MeasureElement(new Size(400, 200))
-                .ExpectChildMeasure(new Size(400, 200), SpacePlan.FullRender(100, 100))
-                .CheckMeasureResult(SpacePlan.FullRender(400, 100));
+                .ExpectChildMeasure(new Size(400, 200), new FullRender(100, 100))
+                .CheckMeasureResult(new FullRender(400, 100));
         }
         
         [Test]
@@ -78,11 +84,8 @@ namespace QuestPDF.UnitTests
                     ExtendVertical = true
                 })
                 .MeasureElement(new Size(400, 200))
-                .ExpectChildMeasure(new Size(400, 200), SpacePlan.FullRender(100, 100))
-                .CheckMeasureResult(SpacePlan.FullRender(100, 200));
+                .ExpectChildMeasure(new Size(400, 200), new FullRender(100, 100))
+                .CheckMeasureResult(new FullRender(100, 200));
         }
-
-        [Test]
-        public void Draw() => SimpleContainerTests.Draw<Extend>();
     }
 }

QuestPDF.UnitTests/GridTests.cs

@@ -1,4 +1,5 @@
 using FluentAssertions;
+using FluentAssertions.Equivalency;
 using NUnit.Framework;
 using QuestPDF.Elements;
 using QuestPDF.Fluent;
@@ -39,30 +40,30 @@ namespace QuestPDF.UnitTests
             // assert
             var expected = new Container();
             
-            expected.Column(column =>
+            expected.Container().Stack(stack =>
             {
-                column.Item().Row(row =>
+                stack.Item().Row(row =>
                 {
-                    row.RelativeItem(6).Element(childA);
-                    row.RelativeItem(4).Element(childB);
-                    row.RelativeItem(2);
+                    row.RelativeColumn(6).Container().Element(childA);
+                    row.RelativeColumn(4).Container().Element(childB);
+                    row.RelativeColumn(2);
                 });
                 
-                column.Item().Row(row =>
+                stack.Item().Row(row =>
                 {
-                    row.RelativeItem(4).Element(childC);
-                    row.RelativeItem(2).Element(childD);
-                    row.RelativeItem(6);
+                    row.RelativeColumn(4).Container().Element(childC);
+                    row.RelativeColumn(2).Container().Element(childD);
+                    row.RelativeColumn(6);
                 });
                 
-                column.Item().Row(row =>
+                stack.Item().Row(row =>
                 {
-                    row.RelativeItem(8).Element(childE);
-                    row.RelativeItem(4);
+                    row.RelativeColumn(8).Container().Element(childE);
+                    row.RelativeColumn(4);
                 });
             });
             
-            TestPlan.CompareOperations(structure, expected);
+            structure.Should().BeEquivalentTo(expected, o => o.WithTracing().WithAutoConversion().WithStrictOrdering().IncludingAllRuntimeProperties());
         }
         
         [Test]
@@ -93,33 +94,33 @@ namespace QuestPDF.UnitTests
             // assert
             var expected = new Container();
             
-            expected.Column(column =>
+            expected.Container().Stack(stack =>
             {
-                column.Item().Row(row =>
+                stack.Item().Row(row =>
                 {
-                    row.RelativeItem(1);
-                    row.RelativeItem(6).Element(childA);
-                    row.RelativeItem(4).Element(childB);
-                    row.RelativeItem(1);
+                    row.RelativeColumn(1);
+                    row.RelativeColumn(6).Container().Element(childA);
+                    row.RelativeColumn(4).Container().Element(childB);
+                    row.RelativeColumn(1);
                 });
                 
-                column.Item().Row(row =>
+                stack.Item().Row(row =>
                 {
-                    row.RelativeItem(3);
-                    row.RelativeItem(4).Element(childC);
-                    row.RelativeItem(2).Element(childD);
-                    row.RelativeItem(3);
+                    row.RelativeColumn(3);
+                    row.RelativeColumn(4).Container().Element(childC);
+                    row.RelativeColumn(2).Container().Element(childD);
+                    row.RelativeColumn(3);
                 });
                 
-                column.Item().Row(row =>
+                stack.Item().Row(row =>
                 {
-                    row.RelativeItem(2);
-                    row.RelativeItem(8).Element(childE);
-                    row.RelativeItem(2);
+                    row.RelativeColumn(2);
+                    row.RelativeColumn(8).Container().Element(childE);
+                    row.RelativeColumn(2);
                 });
             });
 
-            TestPlan.CompareOperations(structure, expected);
+            structure.Should().BeEquivalentTo(expected, o => o.WithTracing().WithAutoConversion().WithStrictOrdering().IncludingAllRuntimeProperties());
         }
         
         [Test]
@@ -150,30 +151,30 @@ namespace QuestPDF.UnitTests
             // assert
             var expected = new Container();
             
-            expected.Column(column =>
+            expected.Container().Stack(stack =>
             {
-                column.Item().Row(row =>
+                stack.Item().Row(row =>
                 {
-                    row.RelativeItem(2);
-                    row.RelativeItem(6).Element(childA);
-                    row.RelativeItem(4).Element(childB);
+                    row.RelativeColumn(2);
+                    row.RelativeColumn(6).Container().Element(childA);
+                    row.RelativeColumn(4).Container().Element(childB);
                 });
                 
-                column.Item().Row(row =>
+                stack.Item().Row(row =>
                 {
-                    row.RelativeItem(6);
-                    row.RelativeItem(4).Element(childC);
-                    row.RelativeItem(2).Element(childD);
+                    row.RelativeColumn(6);
+                    row.RelativeColumn(4).Container().Element(childC);
+                    row.RelativeColumn(2).Container().Element(childD);
                 });
                 
-                column.Item().Row(row =>
+                stack.Item().Row(row =>
                 {
-                    row.RelativeItem(4);
-                    row.RelativeItem(8).Element(childE);
+                    row.RelativeColumn(4);
+                    row.RelativeColumn(8).Container().Element(childE);
                 });
             });
             
-            TestPlan.CompareOperations(structure, expected);
+            structure.Should().BeEquivalentTo(expected, o => o.WithTracing().WithAutoConversion().WithStrictOrdering().IncludingAllRuntimeProperties());
         }
         
         #endregion
@@ -210,40 +211,40 @@ namespace QuestPDF.UnitTests
             // assert
             var expected = new Container();
             
-            expected.Column(column =>
+            expected.Container().Stack(stack =>
             {
-                column.Spacing(20);
+                stack.Spacing(20);
                 
-                column.Item().Row(row =>
+                stack.Item().Row(row =>
                 {
                     row.Spacing(30);
                     
-                    row.RelativeItem(3);
-                    row.RelativeItem(5).Element(childA);
-                    row.RelativeItem(5).Element(childB);
-                    row.RelativeItem(3);
+                    row.RelativeColumn(3);
+                    row.RelativeColumn(5).Container().Element(childA);
+                    row.RelativeColumn(5).Container().Element(childB);
+                    row.RelativeColumn(3);
                 });
                 
-                column.Item().Row(row =>
+                stack.Item().Row(row =>
                 {
                     row.Spacing(30);
                     
-                    row.RelativeItem(3);
-                    row.RelativeItem(10).Element(childC);
-                    row.RelativeItem(3);
+                    row.RelativeColumn(3);
+                    row.RelativeColumn(10).Container().Element(childC);
+                    row.RelativeColumn(3);
                 });
                 
-                column.Item().Row(row =>
+                stack.Item().Row(row =>
                 {
                     row.Spacing(30);
                     
-                    row.RelativeItem(2);
-                    row.RelativeItem(12).Element(childD);
-                    row.RelativeItem(2);
+                    row.RelativeColumn(2);
+                    row.RelativeColumn(12).Container().Element(childD);
+                    row.RelativeColumn(2);
                 });
             });
             
-            TestPlan.CompareOperations(structure, expected);
+            structure.Should().BeEquivalentTo(expected, o => o.WithTracing().WithAutoConversion().WithStrictOrdering().IncludingAllRuntimeProperties().AllowingInfiniteRecursion());
         }
         
         #endregion

QuestPDF.UnitTests/Helpers.cs

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,68 @@
+using NUnit.Framework;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Elements;
+using QuestPDF.Fluent;
+using QuestPDF.Infrastructure;
+using QuestPDF.UnitTests.TestEngine;
+using SkiaSharp;
+
+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()
+        {
+            TestPlan
+                .For(x => new Image
+                {
+                    InternalImage = GenerateImage(400, 300)
+                })
+                .MeasureElement(new Size(300, 200))
+                .CheckMeasureResult(new FullRender(300, 200));
+        }
+        
+        [Test]
+        public void Draw_TakesAvailableSpaceRegardlessOfSize()
+        {
+            TestPlan
+                .For(x => new Image
+                {
+                    InternalImage = GenerateImage(400, 300)
+                })
+                .DrawElement(new Size(300, 200))
+                .ExpectCanvasDrawImage(new Position(0, 0), new Size(300, 200))
+                .CheckDrawResult();
+        }
+        
+        [Test]
+        public void Fluent_RecognizesImageProportions()
+        {
+            var image = GenerateImage(600, 200).Encode(SKEncodedImageFormat.Png, 100).ToArray();
+            
+            TestPlan
+                .For(x =>
+                {
+                    var container = new Container();
+                    container.Image(image);
+                    return container;
+                })
+                .MeasureElement(new Size(300, 200))
+                .CheckMeasureResult(new FullRender(300, 100));;
+        }
+        
+        SKImage GenerateImage(int width, int height)
+        {
+            var imageInfo = new SKImageInfo(width, height);
+            using var surface = SKSurface.Create(imageInfo);
+            return surface.Snapshot();
+        }
+    }
+}

QuestPDF.UnitTests/PaddingTests.cs

@@ -1,5 +1,5 @@
 using NUnit.Framework;
-using QuestPDF.Drawing;
+using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
@@ -9,6 +9,12 @@ 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()
@@ -28,8 +34,8 @@ namespace QuestPDF.UnitTests
             TestPlan
                 .For(GetPadding)
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure(new Size(340, 260), SpacePlan.FullRender(140, 60))
-                .CheckMeasureResult(SpacePlan.FullRender(200, 100));
+                .ExpectChildMeasure(new Size(340, 260), new FullRender(140, 60))
+                .CheckMeasureResult(new FullRender(200, 100));
         } 
         
         [Test]
@@ -38,7 +44,7 @@ namespace QuestPDF.UnitTests
             TestPlan
                 .For(GetPadding)
                 .MeasureElement(new Size(50, 300))
-                .CheckMeasureResult(SpacePlan.Wrap());
+                .CheckMeasureResult(new Wrap());
         }
         
         [Test]
@@ -47,7 +53,7 @@ namespace QuestPDF.UnitTests
             TestPlan
                 .For(GetPadding)
                 .MeasureElement(new Size(20, 300))
-                .CheckMeasureResult(SpacePlan.Wrap());
+                .CheckMeasureResult(new Wrap());
         }
         
         [Test]
@@ -56,8 +62,8 @@ namespace QuestPDF.UnitTests
             TestPlan
                 .For(GetPadding)
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure(new Size(340, 260), SpacePlan.PartialRender(40, 160))
-                .CheckMeasureResult(SpacePlan.PartialRender(100, 200));
+                .ExpectChildMeasure(new Size(340, 260), new PartialRender(40, 160))
+                .CheckMeasureResult(new PartialRender(100, 200));
         }
         
         [Test]
@@ -66,8 +72,8 @@ namespace QuestPDF.UnitTests
             TestPlan
                 .For(GetPadding)
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure(new Size(340, 260), SpacePlan.Wrap())
-                .CheckMeasureResult(SpacePlan.Wrap());
+                .ExpectChildMeasure(new Size(340, 260), new Wrap())
+                .CheckMeasureResult(new Wrap());
         }
         
         [Test]

QuestPDF.UnitTests/PageBreakTests.cs

@@ -1,5 +1,5 @@
 using NUnit.Framework;
-using QuestPDF.Drawing;
+using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
@@ -16,13 +16,13 @@ namespace QuestPDF.UnitTests
                 .For(x => new PageBreak())
                 
                 .MeasureElement(new Size(400, 300))
-                .CheckMeasureResult(SpacePlan.PartialRender(Size.Zero))
+                .CheckMeasureResult(new PartialRender(400, 300))
                 
                 .DrawElement(new Size(400, 300))
                 .CheckDrawResult()
                 
                 .MeasureElement(new Size(500, 400))
-                .CheckMeasureResult(SpacePlan.FullRender(0, 0));
+                .CheckMeasureResult(new FullRender(Size.Zero));
         }
     }
 }

QuestPDF.UnitTests/PageNumberTests.cs

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

QuestPDF.UnitTests/QuestPDF.UnitTests.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netcoreapp3.1</TargetFramework>
+        <IsPackable>false</IsPackable>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="FluentAssertions" Version="5.10.3" />
+        <PackageReference Include="Moq" Version="4.13.1" />
+        <PackageReference Include="nunit" Version="3.13.1" />
+        <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.0" />
+        <PackageReference Include="SkiaSharp" Version="2.80.2" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\QuestPDF\QuestPDF.csproj" />
+    </ItemGroup>
+
+</Project>

QuestPDF.UnitTests/RowTests.cs

@@ -0,0 +1,116 @@
+using NUnit.Framework;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Elements;
+using QuestPDF.Infrastructure;
+using QuestPDF.UnitTests.TestEngine;
+
+namespace QuestPDF.UnitTests
+{
+    [TestFixture]
+    public class RowTests
+    {
+        #region Measure
+        
+        [Test]
+        public void Measure_ReturnsWrap_WhenLeftChildReturnsWrap()
+        {
+            TestPlan
+                .For(x => new SimpleRow
+                {
+                    Left = x.CreateChild("left"),
+                    Right = x.CreateChild("right")
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure("left", new Size(400, 300), new Wrap())
+                .CheckMeasureResult(new Wrap());
+        }
+        
+        [Test]
+        public void Measure_ReturnsWrap_WhenRightChildReturnsWrap()
+        {
+            TestPlan
+                .For(x => new SimpleRow
+                {
+                    Left = x.CreateChild("left"),
+                    Right = x.CreateChild("right")
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure("left", new Size(400, 300), new FullRender(250, 150))
+                .ExpectChildMeasure("right", new Size(150, 300), new Wrap())
+                .CheckMeasureResult(new Wrap());
+        }
+        
+        [Test]
+        public void Measure_ReturnsPartialRender_WhenLeftChildReturnsPartialRender()
+        {
+            TestPlan
+                .For(x => new SimpleRow
+                {
+                    Left = x.CreateChild("left"),
+                    Right = x.CreateChild("right")
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure("left", new Size(400, 300), new PartialRender(250, 150))
+                .ExpectChildMeasure("right", new Size(150, 300), new FullRender(100, 100))
+                .CheckMeasureResult(new PartialRender(350, 150));
+        }
+        
+        [Test]
+        public void Measure_ReturnsPartialRender_WhenRightChildReturnsPartialRender()
+        {
+            TestPlan
+                .For(x => new SimpleRow
+                {
+                    Left = x.CreateChild("left"),
+                    Right = x.CreateChild("right")
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure("left", new Size(400, 300), new FullRender(250, 150))
+                .ExpectChildMeasure("right", new Size(150, 300), new PartialRender(100, 100))
+                .CheckMeasureResult(new PartialRender(350, 150));
+        }
+        
+        [Test]
+        public void Measure_ReturnsFullRender_WhenBothChildrenReturnFullRender()
+        {
+            TestPlan
+                .For(x => new SimpleRow
+                {
+                    Left = x.CreateChild("left"),
+                    Right = x.CreateChild("right")
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure("left", new Size(400, 300), new FullRender(200, 150))
+                .ExpectChildMeasure("right", new Size(200, 300), new FullRender(100, 100))
+                .CheckMeasureResult(new FullRender(300, 150));
+        }
+        
+        #endregion
+
+        #region Draw
+
+        [Test]
+        public void Draw()
+        {
+            TestPlan
+                .For(x => new SimpleRow
+                {
+                    Left = x.CreateChild("left"),
+                    Right = x.CreateChild("right")
+                })
+                .DrawElement(new Size(400, 300))
+                .ExpectChildMeasure("left", new Size(400, 300), new FullRender(250, 150))
+                .ExpectChildDraw("left", new Size(250, 300))
+                .ExpectCanvasTranslate(250, 0)
+                .ExpectChildDraw("right", new Size(150, 300))
+                .ExpectCanvasTranslate(-250, 0)
+                .CheckDrawResult();
+        }
+
+        #endregion
+        
+        // TODO: add tests for the spacing property
+        // TODO: add tests for the tree builder method
+        // TODO: add tests for relative column
+    }
+}

QuestPDF.UnitTests/ShowEntireTests.cs

@@ -1,5 +1,5 @@
 using NUnit.Framework;
-using QuestPDF.Drawing;
+using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
@@ -18,8 +18,8 @@ namespace QuestPDF.UnitTests
                     Child = x.CreateChild()
                 })
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure(new Size(400, 300), SpacePlan.Wrap())
-                .CheckMeasureResult(SpacePlan.Wrap());
+                .ExpectChildMeasure(new Size(400, 300), new Wrap())
+                .CheckMeasureResult(new Wrap());
         }
         
         [Test]
@@ -31,8 +31,8 @@ namespace QuestPDF.UnitTests
                     Child = x.CreateChild()
                 })
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure(new Size(400, 300), SpacePlan.PartialRender(300, 200))
-                .CheckMeasureResult(SpacePlan.Wrap());
+                .ExpectChildMeasure(new Size(400, 300), new PartialRender(300, 200))
+                .CheckMeasureResult(new Wrap());
         }
         
         [Test]
@@ -44,11 +44,8 @@ namespace QuestPDF.UnitTests
                     Child = x.CreateChild()
                 })
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure(new Size(400, 300), SpacePlan.FullRender(300, 200))
-                .CheckMeasureResult(SpacePlan.FullRender(300, 200));
+                .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,6 @@
-using NUnit.Framework;
-using QuestPDF.Drawing;
+using Moq;
+using NUnit.Framework;
+using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
@@ -10,7 +11,33 @@ namespace QuestPDF.UnitTests
     public class ShowOnceTest
     {
         [Test]
-        public void Draw()
+        public void Measure_ShouldHandleNullChild() => new ShowOnce().MeasureWithoutChild();
+        
+        [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()
@@ -20,31 +47,31 @@ namespace QuestPDF.UnitTests
                 
                 // Measure the element and return result
                 .MeasureElement(new Size(300, 200))
-                .ExpectChildMeasure("child", new Size(300, 200), SpacePlan.PartialRender(new Size(200, 200)))
-                .CheckMeasureResult(SpacePlan.PartialRender(new Size(200, 200)))
+                .ExpectChildMeasure("child", new Size(300, 200), new PartialRender(new Size(200, 200)))
+                .CheckMeasureResult(new PartialRender(new Size(200, 200)))
                 
                 // Draw element partially
                 .DrawElement(new Size(200, 200))
-                .ExpectChildMeasure(new Size(200, 200), SpacePlan.PartialRender(new Size(200, 200)))
+                .ExpectChildMeasure(new Size(200, 200), new PartialRender(new Size(200, 200)))
                 .ExpectChildDraw(new Size(200, 200))
                 .CheckDrawResult()
                 
                 // Element was not fully drawn
                 // It should be measured again for rendering on next page
                 .MeasureElement(new Size(800, 200))
-                .ExpectChildMeasure(new Size(800, 200), SpacePlan.FullRender(new Size(400, 200)))
-                .CheckMeasureResult(SpacePlan.FullRender(new Size(400, 200)))
+                .ExpectChildMeasure(new Size(800, 200), new FullRender(new Size(400, 200)))
+                .CheckMeasureResult(new FullRender(new Size(400, 200)))
 
                 // Draw element on next page
                 // Element was fully drawn at this point
                 .DrawElement(new Size(400, 200))
-                .ExpectChildMeasure(new Size(400, 200), SpacePlan.FullRender(new Size(400, 200)))
+                .ExpectChildMeasure(new Size(400, 200), new FullRender(new Size(400, 200)))
                 .ExpectChildDraw(new Size(400, 200))
                 .CheckDrawResult()
                 
                 // In the next attempt of measuring element, it should behave like empty parent.
                 .MeasureElement(new Size(600, 200))
-                .CheckMeasureResult(SpacePlan.FullRender(0, 0))
+                .CheckMeasureResult(new FullRender(Size.Zero))
                 
                 // In the next attempt of measuring element, it should not draw its child
                 .DrawElement(new Size(600, 200))

QuestPDF.UnitTests/StackTests.cs

@@ -1,96 +1,105 @@
-using System.Linq;
-using NUnit.Framework;
-using QuestPDF.Drawing;
+using NUnit.Framework;
+using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Elements;
-using QuestPDF.Fluent;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
 
 namespace QuestPDF.UnitTests
 {
     [TestFixture]
-    public class ColumnTests
+    public class StackTests
     {
-        private Column CreateColumnWithTwoItems(TestPlan testPlan)
-        {
-            return new Column
-            {
-                Items =
-                {
-                    new ColumnItem
-                    {
-                        Child = testPlan.CreateChild("first")
-                    },
-                    new ColumnItem
-                    {
-                        Child = testPlan.CreateChild("second")
-                    }
-                }
-            };
-        }
-        
-        private Column CreateColumnWithTwoItemsWhereFirstIsFullyRendered(TestPlan testPlan)
-        {
-            var column = CreateColumnWithTwoItems(testPlan);
-            column.Items.First().IsRendered = true;
-            return column;
-        }
-        
         #region Measure
 
         [Test]
         public void Measure_ReturnsWrap_WhenFirstChildWraps()
         {
             TestPlan
-                .For(CreateColumnWithTwoItems)
+                .For(x => new SimpleStack
+                {
+                    First = x.CreateChild("first"),
+                    Second = x.CreateChild("second")
+                })
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure("first", new Size(400, 300), SpacePlan.Wrap())
-                .CheckMeasureResult(SpacePlan.Wrap());
+                .ExpectChildMeasure("first", new Size(400, 300), new Wrap())
+                .CheckMeasureResult(new Wrap());
         }
         
         [Test]
         public void Measure_ReturnsPartialRender_WhenFirstChildReturnsPartialRender()
         {
             TestPlan
-                .For(CreateColumnWithTwoItems)
+                .For(x => new SimpleStack
+                {
+                    First = x.CreateChild("first"),
+                    Second = x.CreateChild("second")
+                })
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure("first", new Size(400, 300), SpacePlan.PartialRender(300, 200))
-                .CheckMeasureResult(SpacePlan.PartialRender(300, 200));
+                .ExpectChildMeasure("first", new Size(400, 300), new PartialRender(300, 200))
+                .CheckMeasureResult(new PartialRender(300, 200));
         }
         
         [Test]
         public void Measure_ReturnsPartialRender_WhenSecondChildWraps()
         {
             TestPlan
-                .For(CreateColumnWithTwoItems)
+                .For(x => new SimpleStack
+                {
+                    First = x.CreateChild("first"),
+                    Second = x.CreateChild("second")
+                })
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure("first", new Size(400, 300), SpacePlan.FullRender(200, 100))
-                .ExpectChildMeasure("second", new Size(400, 200), SpacePlan.Wrap())
-                .CheckMeasureResult(SpacePlan.PartialRender(200, 100));
+                .ExpectChildMeasure("first", new Size(400, 300), new FullRender(200, 100))
+                .ExpectChildMeasure("second", new Size(400, 200), new Wrap())
+                .CheckMeasureResult(new PartialRender(200, 100));
         }
         
         [Test]
         public void Measure_ReturnsPartialRender_WhenSecondChildReturnsPartialRender()
         {
             TestPlan
-                .For(CreateColumnWithTwoItems)
+                .For(x => new SimpleStack
+                {
+                    First = x.CreateChild("first"),
+                    Second = x.CreateChild("second")
+                })
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure("first", new Size(400, 300), SpacePlan.FullRender(200, 100))
-                .ExpectChildMeasure("second", new Size(400, 200), SpacePlan.PartialRender(300, 150))
-                .CheckMeasureResult(SpacePlan.PartialRender(300, 250));
+                .ExpectChildMeasure("first", new Size(400, 300), new FullRender(200, 100))
+                .ExpectChildMeasure("second", new Size(400, 200), new PartialRender(300, 150))
+                .CheckMeasureResult(new PartialRender(300, 250));
         }
         
         [Test]
         public void Measure_ReturnsFullRender_WhenSecondChildReturnsFullRender()
         {
             TestPlan
-                .For(CreateColumnWithTwoItems)
+                .For(x => new SimpleStack
+                {
+                    First = x.CreateChild("first"),
+                    Second = x.CreateChild("second")
+                })
                 .MeasureElement(new Size(400, 300))
-                .ExpectChildMeasure("first", new Size(400, 300), SpacePlan.FullRender(200, 100))
-                .ExpectChildMeasure("second", new Size(400, 200), SpacePlan.FullRender(100, 50))
-                .CheckMeasureResult(SpacePlan.FullRender(200, 150));
+                .ExpectChildMeasure("first", new Size(400, 300), new FullRender(200, 100))
+                .ExpectChildMeasure("second", new Size(400, 200), new FullRender(100, 50))
+                .CheckMeasureResult(new FullRender(200, 150));
         }
-
+        
+        [Test]
+        public void Measure_UsesEmpty_WhenFirstChildIsRendered()
+        {
+            TestPlan
+                .For(x => new SimpleStack
+                {
+                    First = x.CreateChild("first"),
+                    Second = x.CreateChild("second"),
+                    
+                    IsFirstRendered = true
+                })
+                .MeasureElement(new Size(400, 300))
+                .ExpectChildMeasure("second", new Size(400, 300), new FullRender(200, 300))
+                .CheckMeasureResult(new FullRender(200, 300));
+        }
+        
         #endregion
         
         #region Draw
@@ -99,9 +108,13 @@ namespace QuestPDF.UnitTests
         public void Draw_WhenFirstChildWraps()
         {
             TestPlan
-                .For(CreateColumnWithTwoItems)
+                .For(x => new SimpleStack
+                {
+                    First = x.CreateChild("first"),
+                    Second = x.CreateChild("second")
+                })
                 .DrawElement(new Size(400, 300))
-                .ExpectChildMeasure("first", new Size(400, 300), SpacePlan.Wrap())
+                .ExpectChildMeasure("first", new Size(400, 300), new Wrap())
                 .CheckDrawResult();
         }
         
@@ -109,12 +122,14 @@ namespace QuestPDF.UnitTests
         public void Draw_WhenFirstChildPartiallyRenders()
         {
             TestPlan
-                .For(CreateColumnWithTwoItems)
+                .For(x => new SimpleStack
+                {
+                    First = x.CreateChild("first"),
+                    Second = x.CreateChild("second")
+                })
                 .DrawElement(new Size(400, 300))
-                .ExpectChildMeasure("first", new Size(400, 300), SpacePlan.PartialRender(200, 100))
-                .ExpectCanvasTranslate(0, 0)
+                .ExpectChildMeasure("first", new Size(400, 300), new PartialRender(200, 100))
                 .ExpectChildDraw("first", new Size(400, 100))
-                .ExpectCanvasTranslate(0, 0)
                 .CheckDrawResult();
         }
         
@@ -122,13 +137,15 @@ namespace QuestPDF.UnitTests
         public void Draw_WhenFirstChildFullyRenders_AndSecondChildWraps()
         {
             TestPlan
-                .For(CreateColumnWithTwoItems)
+                .For(x => new SimpleStack
+                {
+                    First = x.CreateChild("first"),
+                    Second = x.CreateChild("second")
+                })
                 .DrawElement(new Size(400, 300))
-                .ExpectChildMeasure("first", new Size(400, 300), SpacePlan.FullRender(200, 100))
-                .ExpectChildMeasure("second", new Size(400, 200), SpacePlan.Wrap())
-                .ExpectCanvasTranslate(0, 0)
+                .ExpectChildMeasure("first", new Size(400, 300), new FullRender(200, 100))
                 .ExpectChildDraw("first", new Size(400, 100))
-                .ExpectCanvasTranslate(0, 0)
+                .ExpectChildMeasure("second", new Size(400, 200), new Wrap())
                 .CheckDrawResult();
         }
         
@@ -136,13 +153,15 @@ namespace QuestPDF.UnitTests
         public void Draw_WhenFirstChildFullyRenders_AndSecondChildPartiallyRenders()
         {
             TestPlan
-                .For(CreateColumnWithTwoItems)
+                .For(x => new SimpleStack
+                {
+                    First = x.CreateChild("first"),
+                    Second = x.CreateChild("second")
+                })
                 .DrawElement(new Size(400, 300))
-                .ExpectChildMeasure("first", new Size(400, 300), SpacePlan.FullRender(200, 100))
-                .ExpectChildMeasure("second", new Size(400, 200), SpacePlan.PartialRender(250, 150))
-                .ExpectCanvasTranslate(0, 0)
+                .ExpectChildMeasure("first", new Size(400, 300), new FullRender(200, 100))
                 .ExpectChildDraw("first", new Size(400, 100))
-                .ExpectCanvasTranslate(0, 0)
+                .ExpectChildMeasure("second", new Size(400, 200), new PartialRender(250, 150))
                 .ExpectCanvasTranslate(0, 100)
                 .ExpectChildDraw("second", new Size(400, 150))
                 .ExpectCanvasTranslate(0, -100)
@@ -153,13 +172,15 @@ namespace QuestPDF.UnitTests
         public void Draw_WhenFirstChildFullyRenders_AndSecondChildFullyRenders()
         {
             TestPlan
-                .For(CreateColumnWithTwoItems)
+                .For(x => new SimpleStack
+                {
+                    First = x.CreateChild("first"),
+                    Second = x.CreateChild("second")
+                })
                 .DrawElement(new Size(400, 300))
-                .ExpectChildMeasure("first", new Size(400, 300), SpacePlan.FullRender(200, 100))
-                .ExpectChildMeasure("second", new Size(400, 200), SpacePlan.FullRender(250, 150))
-                .ExpectCanvasTranslate(0, 0)
+                .ExpectChildMeasure("first", new Size(400, 300), new FullRender(200, 100))
                 .ExpectChildDraw("first", new Size(400, 100))
-                .ExpectCanvasTranslate(0, 0)
+                .ExpectChildMeasure("second", new Size(400, 200), new FullRender(250, 150))
                 .ExpectCanvasTranslate(0, 100)
                 .ExpectChildDraw("second", new Size(400, 150))
                 .ExpectCanvasTranslate(0, -100)
@@ -170,13 +191,19 @@ namespace QuestPDF.UnitTests
         public void Draw_UsesEmpty_WhenFirstChildIsRendered()
         {
             TestPlan
-                .For(CreateColumnWithTwoItemsWhereFirstIsFullyRendered)
+                .For(x => new SimpleStack
+                {
+                    First = x.CreateChild("first"),
+                    Second = x.CreateChild("second"),
+                    
+                    IsFirstRendered = true
+                })
                 .DrawElement(new Size(400, 300))
-                .ExpectChildMeasure("second", new Size(400, 300), SpacePlan.PartialRender(200, 300))
+                .ExpectChildMeasure("second", new Size(400, 300), new PartialRender(200, 300))
                 .ExpectCanvasTranslate(0, 0)
                 .ExpectChildDraw("second", new Size(400, 300))
                 .ExpectCanvasTranslate(0, 0)
-                .CheckState<Column>(x => x.Items.First().IsRendered)
+                .CheckState<SimpleStack>(x => x.IsFirstRendered)
                 .CheckDrawResult();
         }
         
@@ -184,16 +211,25 @@ namespace QuestPDF.UnitTests
         public void Draw_TogglesFirstRenderedFlag_WhenSecondFullyRenders()
         {
             TestPlan
-                .For(CreateColumnWithTwoItemsWhereFirstIsFullyRendered)
+                .For(x => new SimpleStack
+                {
+                    First = x.CreateChild("first"),
+                    Second = x.CreateChild("second"),
+                    
+                    IsFirstRendered = true
+                })
                 .DrawElement(new Size(400, 300))
-                .ExpectChildMeasure("second", new Size(400, 300), SpacePlan.FullRender(200, 300))
+                .ExpectChildMeasure("second", new Size(400, 300), new FullRender(200, 300))
                 .ExpectCanvasTranslate(0, 0)
                 .ExpectChildDraw("second", new Size(400, 300))
                 .ExpectCanvasTranslate(0, 0)
                 .CheckDrawResult()
-                .CheckState<Column>(x => !x.Items.First().IsRendered);
+                .CheckState<SimpleStack>(x => !x.IsFirstRendered);
         }
         
         #endregion
+        
+        // TODO: add tests for the spacing property
+        // TODO: add tests for the tree builder method
     }
 }

QuestPDF.UnitTests/TestEngine/CanvasMock.cs

@@ -0,0 +1,43 @@
+using System;
+using QuestPDF.Infrastructure;
+using SkiaSharp;
+
+namespace QuestPDF.UnitTests.TestEngine
+{
+    internal class CanvasMock : ICanvas
+    {
+        public Action<Position> TranslateFunc { 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 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)
+        {
+            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/ElementMock.cs

@@ -0,0 +1,16 @@
+using System;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.UnitTests.TestEngine
+{
+    internal class ElementMock : Element
+    {
+        public string Id { get; set; }
+        public Func<Size, ISpacePlan> MeasureFunc { get; set; }
+        public Action<Size> DrawFunc { get; set; }
+
+        internal override ISpacePlan Measure(Size availableSpace) => MeasureFunc(availableSpace);
+        internal override void Draw(ICanvas canvas, Size availableSpace) => DrawFunc(availableSpace);
+    }
+}

QuestPDF.UnitTests/TestEngine/Operations/CanvasDrawImageOperation.cs

@@ -2,12 +2,12 @@
 
 namespace QuestPDF.UnitTests.TestEngine.Operations
 {
-    internal class CanvasDrawImageOperation : OperationBase
+    internal class CanvasDrawImageOperationBase : OperationBase
     {
         public Position Position { get; }
         public Size Size { get; }
 
-        public CanvasDrawImageOperation(Position position, Size size)
+        public CanvasDrawImageOperationBase(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 CanvasDrawRectangleOperation : OperationBase
+    internal class CanvasDrawRectangleOperationBase : OperationBase
     {
         public Position Position { get; } 
         public Size Size { get; }
         public string Color { get; }
 
-        public CanvasDrawRectangleOperation(Position position, Size size, string color)
+        public CanvasDrawRectangleOperationBase(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 CanvasDrawTextOperation : OperationBase
+    internal class CanvasDrawTextOperationBase : OperationBase
     {
         public string Text { get; }
         public Position Position { get; }
         public TextStyle Style { get; }
 
-        public CanvasDrawTextOperation(string text, Position position, TextStyle style)
+        public CanvasDrawTextOperationBase(string text, Position position, TextStyle style)
         {
             Text = text;
             Position = position;

QuestPDF.UnitTests/TestEngine/Operations/CanvasTranslateOperation.cs

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

QuestPDF.UnitTests/TestEngine/Operations/ChildDrawOperation.cs

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

QuestPDF.UnitTests/TestEngine/Operations/ChildMeasureOperation.cs

@@ -1,15 +1,15 @@
-using QuestPDF.Drawing;
+using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Infrastructure;
 
 namespace QuestPDF.UnitTests.TestEngine.Operations
 {
-    internal class ChildMeasureOperation : OperationBase
+    internal class ChildMeasureOperationBase : OperationBase
     {
         public string ChildId { get; }
         public Size Input { get; }
-        public SpacePlan Output { get; }
+        public ISpacePlan Output { get; }
 
-        public ChildMeasureOperation(string childId, Size input, SpacePlan output)
+        public ChildMeasureOperationBase(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 ElementMeasureOperation : OperationBase
+    public class ElementMeasureOperationBase : OperationBase
     {
-        public ElementMeasureOperation(Size input)
+        public ElementMeasureOperationBase(Size input)
         {
             
         }

QuestPDF.UnitTests/TestEngine/SingleChildTests.cs

@@ -0,0 +1,31 @@
+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,11 +1,9 @@
 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;
 
@@ -14,8 +12,6 @@ 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; }
@@ -48,31 +44,20 @@ namespace QuestPDF.UnitTests.TestEngine
         
         private ICanvas CreateCanvas()
         {
-            return new MockCanvas
+            return new CanvasMock
             {
                 TranslateFunc = position =>
                 {
-                    var expected = GetExpected<CanvasTranslateOperation>();
+                    var expected = GetExpected<CanvasTranslateOperationBase>();
 
                     Assert.AreEqual(expected.Position.X, position.X, "Translate X");
                     Assert.AreEqual(expected.Position.Y, position.Y, "Translate Y");
-                },
-                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");
+                    
+                    //position.Should().BeEquivalentTo(expected.Position);
                 },
                 DrawRectFunc = (position, size, color) =>
                 {
-                    var expected = GetExpected<CanvasDrawRectangleOperation>();
+                    var expected = GetExpected<CanvasDrawRectangleOperationBase>();
                     
                     Assert.AreEqual(expected.Position.X, position.X, "Draw rectangle: X");
                     Assert.AreEqual(expected.Position.Y, position.Y, "Draw rectangle: Y");
@@ -81,16 +66,40 @@ 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>();
+                    
+                    Assert.AreEqual(expected.Text, text);
+                    
+                    Assert.AreEqual(expected.Position.X, position.X, "Draw text: X");
+                    Assert.AreEqual(expected.Position.Y, position.Y, "Draw text: Y");
+                    
+                    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<CanvasDrawImageOperation>();
+                    var expected = GetExpected<CanvasDrawImageOperationBase>();
                     
                     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);*/
                 }
             };
         }
@@ -104,23 +113,29 @@ namespace QuestPDF.UnitTests.TestEngine
                 Id = id,
                 MeasureFunc = availableSpace =>
                 {
-                    var expected = GetExpected<ChildMeasureOperation>();
+                    var expected = GetExpected<ChildMeasureOperationBase>();
 
                     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<ChildDrawOperation>();
+                    var expected = GetExpected<ChildDrawOperationBase>();
 
                     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);*/
                 }
             };
         }
@@ -143,14 +158,14 @@ namespace QuestPDF.UnitTests.TestEngine
             return this;
         }
         
-        public TestPlan ExpectChildMeasure(Size expectedInput, SpacePlan returns)
+        public TestPlan ExpectChildMeasure(Size expectedInput, ISpacePlan returns)
         {
             return ExpectChildMeasure(DefaultChildName, expectedInput, returns);
         }
         
-        public TestPlan ExpectChildMeasure(string child, Size expectedInput, SpacePlan returns)
+        public TestPlan ExpectChildMeasure(string child, Size expectedInput, ISpacePlan returns)
         {
-            return AddOperation(new ChildMeasureOperation(child, expectedInput, returns));
+            return AddOperation(new ChildMeasureOperationBase(child, expectedInput, returns));
         }
         
         public TestPlan ExpectChildDraw(Size expectedInput)
@@ -160,58 +175,55 @@ namespace QuestPDF.UnitTests.TestEngine
         
         public TestPlan ExpectChildDraw(string child, Size expectedInput)
         {
-            return AddOperation(new ChildDrawOperation(child, expectedInput));
+            return AddOperation(new ChildDrawOperationBase(child, expectedInput));
         }
 
         public TestPlan ExpectCanvasTranslate(Position position)
         {
-            return AddOperation(new CanvasTranslateOperation(position));
+            return AddOperation(new CanvasTranslateOperationBase(position));
         }
         
         public TestPlan ExpectCanvasTranslate(float left, float top)
         {
-            return AddOperation(new CanvasTranslateOperation(new Position(left, top)));
+            return AddOperation(new CanvasTranslateOperationBase(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 CanvasDrawRectangleOperation(position, size, color));
+            return AddOperation(new CanvasDrawRectangleOperationBase(position, size, color));
+        }
+        
+        public TestPlan ExpectCanvasDrawText(string text, Position position, TextStyle style)
+        {
+            return AddOperation(new CanvasDrawTextOperationBase(text, position, style));
         }
         
         public TestPlan ExpectCanvasDrawImage(Position position, Size size)
         {
-            return AddOperation(new CanvasDrawImageOperation(position, size));
+            return AddOperation(new CanvasDrawImageOperationBase(position, size));
         }
         
-        public TestPlan CheckMeasureResult(SpacePlan expected)
+        public TestPlan CheckMeasureResult(ISpacePlan expected)
         {
-            Element.InjectDependencies(null, Canvas);
-            
             var actual = Element.Measure(OperationInput);
             
             Assert.AreEqual(expected.GetType(), actual.GetType());
-            
-            Assert.AreEqual(expected.Width, actual.Width, "Measure: width");
-            Assert.AreEqual(expected.Height, actual.Height, "Measure: height");
-            Assert.AreEqual(expected.Type, actual.Type, "Measure: height");
+
+            var expectedSize = expected as Size;
+            var actualSize = actual as Size;
+
+            if (expectedSize != null)
+            {
+                Assert.AreEqual(expectedSize.Width, actualSize.Width, "Measure: width");
+                Assert.AreEqual(expectedSize.Height, actualSize.Height, "Measure: height");
+            }
             
             return this;
         }
         
         public TestPlan CheckDrawResult()
         {
-            Element.InjectDependencies(null, Canvas);
-            Element.Draw(OperationInput);
+            Element.Draw(Canvas, OperationInput);
             return this;
         }
 
@@ -230,53 +242,10 @@ namespace QuestPDF.UnitTests.TestEngine
         
         public static Element CreateUniqueElement()
         {
-            return new Constrained
+            return new Text
             {
-                MinWidth = 90,
-                MinHeight = 60,
-                
-                Child = new DynamicImage
-                {
-                    CompressionQuality = ImageCompressionQuality.Medium,
-                    TargetDpi = DocumentSettings.DefaultRasterDpi,
-                    Source = Placeholders.Image
-                }
+                Value = Guid.NewGuid().ToString("N")
             };
         }
-
-        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.InjectDependencies(null, canvas);
-            var valueMeasure = value.Measure(availableSpace.Value);
-            
-            expected.InjectDependencies(null, canvas);
-            var expectedMeasure = expected.Measure(availableSpace.Value);
-            
-            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.InjectDependencies(null, valueCanvas);
-            value.Draw(availableSpace.Value);
-            
-            var expectedCanvas = new OperationRecordingCanvas();
-            expected.InjectDependencies(null, expectedCanvas);
-            expected.Draw(availableSpace.Value);
-            
-            valueCanvas.Operations.Should().BeEquivalentTo(expectedCanvas.Operations);
-        }
     }
 }

QuestPDF.UnitTests/TextTests.cs

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

QuestPDF.sln

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

QuestPDF/Assembly.cs

@@ -0,0 +1,5 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
+[assembly: InternalsVisibleTo("QuestPDF.UnitTests")]
+[assembly: InternalsVisibleTo("QuestPDF.Examples")]

QuestPDF/Drawing/Canvas.cs

@@ -0,0 +1,59 @@
+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/CanvasCache.cs

@@ -0,0 +1,63 @@
+using System.Collections.Concurrent;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Infrastructure;
+using SkiaSharp;
+
+namespace QuestPDF.Drawing
+{
+    internal static class CanvasCache
+    {
+        private static ConcurrentDictionary<string, SKPaint> Paints = new ConcurrentDictionary<string, SKPaint>();
+        private static ConcurrentDictionary<string, SKPaint> ColorPaint = new ConcurrentDictionary<string, SKPaint>();
+
+        internal static SKPaint ColorToPaint(this string color)
+        {
+            return ColorPaint.GetOrAdd(color, Convert);
+
+            static SKPaint Convert(string color)
+            {
+                return new SKPaint
+                {
+                    Color = SKColor.Parse(color)
+                };
+            }
+        }
+        
+        internal static SKPaint ToPaint(this TextStyle style)
+        {
+            return Paints.GetOrAdd(style.ToString(), key => Convert(style));
+            
+            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),
+                    TextSize = style.Size,
+                    TextEncoding = SKTextEncoding.Utf32,
+
+                    TextAlign = style.Alignment switch
+                    {
+                        HorizontalAlignment.Left => SKTextAlign.Left,
+                        HorizontalAlignment.Center => SKTextAlign.Center,
+                        HorizontalAlignment.Right => SKTextAlign.Right,
+                        _ => SKTextAlign.Left
+                    }
+                };
+            }
+        }
+
+        internal static TextMeasurement BreakText(this TextStyle style, string text, float availableWidth)
+        {
+            var index = (int)style.ToPaint().BreakText(text, availableWidth, out var width);
+            
+            return new TextMeasurement()
+            {
+                LineIndex = index,
+                FragmentWidth = width
+            };
+        }
+    }
+}

QuestPDF/Drawing/DocumentGenerator.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using QuestPDF.Drawing.Exceptions;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Fluent;
+using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
+using SkiaSharp;
+
+namespace QuestPDF.Drawing
+{
+    static class DocumentGenerator
+    {
+        internal static void GeneratePdf(Stream stream, IDocument document)
+        {
+            var content = ElementExtensions.Create(document.Compose);
+            var metadata = document.GetMetadata();
+            
+            using var pdf = SKDocument.CreatePdf(stream, MapMetadata(metadata));
+            var totalPages = 1;
+            
+            while(true)
+            {
+                var spacePlan = content.Measure(metadata.Size);
+
+                using var skiaCanvas = pdf.BeginPage(metadata.Size.Width, metadata.Size.Height);
+                var canvas = new Canvas(skiaCanvas);
+
+                try
+                {
+                    content.Draw(canvas, metadata.Size);
+                }
+                catch (Exception exception)
+                {
+                    pdf.Close();
+                    throw new DocumentDrawingException("An exception occured during document drawing.", exception);
+                }
+
+                pdf.EndPage();
+
+                if (totalPages >= metadata.DocumentLayoutExceptionThreshold)
+                {
+                    pdf.Close();
+                    throw new DocumentLayoutException("Composed layout generates infinite document.");
+                }
+                
+                if (spacePlan is FullRender)
+                    break;
+
+                totalPages++;
+            }
+            
+            pdf.Close();
+        }
+
+        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);
+                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

@@ -0,0 +1,32 @@
+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; }
+        
+        public string? Title { get; set; }
+        public string? Author { get; set; }
+        public string? Subject { get; set; }
+        public string? Keywords { get; set; }
+        public string? Creator { get; set; }
+        public string? Producer { get; set; }
+
+        public DateTime CreationDate { get; set; } = DateTime.Now;
+        public DateTime ModifiedDate { get; set; } = DateTime.Now;
+
+        /// <summary>
+        /// If the number of generated pages exceeds this threshold
+        /// (likely due to infinite layout), the exception is thrown.
+        /// </summary>
+        public int DocumentLayoutExceptionThreshold { get; set; } = 250;
+        
+        public static DocumentMetadata Default => new DocumentMetadata();
+    }
+}

QuestPDF/Drawing/Exceptions/DocumentComposeException.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace QuestPDF.Drawing.Exceptions
+{
+    public class DocumentComposeException : Exception
+    {
+        public DocumentComposeException()
+        {
+            
+        }
+
+        public DocumentComposeException(string message) : base(message)
+        {
+            
+        }
+
+        public DocumentComposeException(string message, Exception inner) : base(message, inner)
+        {
+            
+        }
+    }
+}

QuestPDF/Drawing/Exceptions/DocumentDrawingException.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace QuestPDF.Drawing.Exceptions
+{
+    public class DocumentDrawingException : Exception
+    {
+        public DocumentDrawingException()
+        {
+            
+        }
+
+        public DocumentDrawingException(string message) : base(message)
+        {
+            
+        }
+
+        public DocumentDrawingException(string message, Exception inner) : base(message, inner)
+        {
+            
+        }
+    }
+}

QuestPDF/Drawing/Exceptions/DocumentLayoutException.cs

@@ -0,0 +1,22 @@
+using System;
+
+namespace QuestPDF.Drawing.Exceptions
+{
+    public class DocumentLayoutException : Exception
+    {
+        public DocumentLayoutException()
+        {
+            
+        }
+
+        public DocumentLayoutException(string message) : base(message)
+        {
+            
+        }
+
+        public DocumentLayoutException(string message, Exception inner) : base(message, inner)
+        {
+            
+        }
+    }
+}

QuestPDF/Drawing/SpacePlan/FullRender.cs

@@ -0,0 +1,19 @@
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Drawing.SpacePlan
+{
+    internal class FullRender : Size, ISpacePlan
+    {
+        public FullRender(Size size) : this(size.Width, size.Height)
+        {
+            
+        }
+        
+        public FullRender(float width, float height) : base(width, height)
+        {
+            
+        }
+        
+        public override string ToString() => $"FullRender {base.ToString()}";
+    }
+}

QuestPDF/Drawing/SpacePlan/ISpacePlan.cs

@@ -0,0 +1,7 @@
+namespace QuestPDF.Drawing.SpacePlan
+{
+    internal interface ISpacePlan
+    {
+        
+    }
+}

QuestPDF/Drawing/SpacePlan/PartialRender.cs

@@ -0,0 +1,19 @@
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Drawing.SpacePlan
+{
+    internal class PartialRender : Size, ISpacePlan
+    {
+        public PartialRender(Size size) : this(size.Width, size.Height)
+        {
+            
+        }
+        
+        public PartialRender(float width, float height) : base(width, height)
+        {
+            
+        }
+        
+        public override string ToString() => $"PartialRender {base.ToString()}";
+    }
+}

QuestPDF/Drawing/SpacePlan/TextMeasurement.cs

@@ -0,0 +1,8 @@
+namespace QuestPDF.Drawing.SpacePlan
+{
+    internal struct TextMeasurement
+    {
+        public int LineIndex { get; set; }
+        public float FragmentWidth { get; set; }
+    }
+}

QuestPDF/Drawing/SpacePlan/Wrap.cs

@@ -0,0 +1,7 @@
+namespace QuestPDF.Drawing.SpacePlan
+{
+    internal class Wrap : ISpacePlan
+    {
+        public override string ToString() => "Wrap";
+    }
+}

QuestPDF/Elements/Alignment.cs

@@ -1,34 +1,29 @@
 using System;
-using QuestPDF.Drawing;
 using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Elements
 {
     internal class Alignment : ContainerElement
     {
-        public VerticalAlignment? Vertical { get; set; }
-        public HorizontalAlignment? Horizontal { get; set; }
+        public VerticalAlignment Vertical { get; set; } = VerticalAlignment.Top;
+        public HorizontalAlignment Horizontal { get; set; } = HorizontalAlignment.Left;
         
-        internal override void Draw(Size availableSpace)
+        internal override void Draw(ICanvas canvas, Size availableSpace)
         {
             if (Child == null)
                 return;
             
-            var childMeasurement = base.Measure(availableSpace);
+            var childSize = Child.Measure(availableSpace) as Size;
             
-            if (childMeasurement.Type == SpacePlanType.Wrap)
+            if (childSize == null)
                 return;
-
-            var childSize = new Size(
-                Horizontal.HasValue ? childMeasurement.Width : availableSpace.Width,
-                Vertical.HasValue ? childMeasurement.Height : availableSpace.Height);
-
+            
             var top = GetTopOffset(availableSpace, childSize);
             var left = GetLeftOffset(availableSpace, childSize);
             
-            Canvas.Translate(new Position(left, top));
-            base.Draw(childSize);
-            Canvas.Translate(new Position(-left, -top));
+            canvas.Translate(new Position(left, top));
+            Child.Draw(canvas, childSize);
+            canvas.Translate(new Position(-left, -top));
         }
         
         private float GetTopOffset(Size availableSpace, Size childSize)
@@ -40,7 +35,7 @@ namespace QuestPDF.Elements
                 VerticalAlignment.Top => 0,
                 VerticalAlignment.Middle => difference / 2,
                 VerticalAlignment.Bottom => difference,
-                _ => 0
+                _ => throw new NotSupportedException()
             };
         }
         
@@ -53,7 +48,7 @@ namespace QuestPDF.Elements
                 HorizontalAlignment.Left => 0,
                 HorizontalAlignment.Center => difference / 2,
                 HorizontalAlignment.Right => difference,
-                _ => 0
+                _ => throw new NotSupportedException()
             };
         }
     }

QuestPDF/Elements/AspectRatio.cs

@@ -0,0 +1,64 @@
+using System;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Elements
+{
+    internal class AspectRatio : ContainerElement
+    {
+        public float Ratio { get; set; } = 1;
+        public AspectRatioOption Option { get; set; } = AspectRatioOption.FitWidth;
+        
+        internal override ISpacePlan Measure(Size availableSpace)
+        {
+            if(Child == null)
+                return new FullRender(Size.Zero);
+            
+            var targetSize = GetTargetSize(availableSpace);
+            
+            if (targetSize.Height > availableSpace.Height + Size.Epsilon)
+                return new Wrap();
+            
+            if (targetSize.Width > availableSpace.Width + Size.Epsilon)
+                return new Wrap();
+
+            var childSize = Child.Measure(targetSize);
+
+            if (childSize is Wrap)
+                return new Wrap();
+
+            if (childSize is PartialRender)
+                return new PartialRender(targetSize);
+
+            if (childSize is FullRender)
+                return new FullRender(targetSize);
+            
+            throw new NotSupportedException();
+        }
+
+        internal override void Draw(ICanvas canvas, Size availableSpace)
+        {
+            if (Child == null)
+                return;
+            
+            var size = GetTargetSize(availableSpace);
+            Child?.Draw(canvas, size);
+        }
+        
+        private Size GetTargetSize(Size availableSpace)
+        {
+            var spaceRatio = availableSpace.Width / availableSpace.Height;
+
+            var fitHeight = new Size(availableSpace.Height * Ratio, availableSpace.Height) ;
+            var fitWidth = new Size(availableSpace.Width, availableSpace.Width / Ratio);
+
+            return Option switch
+            {
+                AspectRatioOption.FitWidth => fitWidth,
+                AspectRatioOption.FitHeight => fitHeight,
+                AspectRatioOption.FitArea => Ratio < spaceRatio ? fitHeight : fitWidth,
+                _ => throw new ArgumentOutOfRangeException()
+            };
+        }
+    }
+}

QuestPDF/Elements/Background.cs

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

QuestPDF/Elements/Border.cs

@@ -12,34 +12,29 @@ namespace QuestPDF.Elements
         public float Bottom { get; set; }
         public float Left { get; set; }
 
-        internal override void Draw(Size availableSpace)
+        internal override void Draw(ICanvas canvas, Size availableSpace)
         {
-            base.Draw(availableSpace);
+            Child?.Draw(canvas, 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);
         }
-
-        public override string ToString()
-        {
-            return $"Border: Top({Top}) Right({Right}) Bottom({Bottom}) Left({Left}) Color({Color})";
-        }
     }
 }

QuestPDF/Elements/Box.cs

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

QuestPDF/Elements/Canvas.cs

@@ -0,0 +1,30 @@
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Infrastructure;
+using SkiaSharp;
+
+namespace QuestPDF.Elements
+{
+    public delegate void DrawOnCanvas(SKCanvas canvas, Size availableSpace);
+    
+    internal class Canvas : Element
+    {
+        public DrawOnCanvas Handler { get; set; }
+        
+        internal override ISpacePlan Measure(Size availableSpace)
+        {
+            return new FullRender(availableSpace);
+        }
+
+        internal override void Draw(ICanvas canvas, Size availableSpace)
+        {
+            var skiaCanvas = (canvas as Drawing.Canvas)?.SkiaCanvas;
+            
+            if (Handler == null || skiaCanvas == null)
+                return;
+
+            var currentMatrix = skiaCanvas.TotalMatrix;
+            Handler.Invoke(skiaCanvas, availableSpace);
+            skiaCanvas.SetMatrix(currentMatrix);
+        }
+    }
+}

QuestPDF/Elements/Constrained.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Linq;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Elements
+{
+    internal class Constrained : ContainerElement
+    {
+        public float? MinWidth { get; set; }
+        public float? MaxWidth { get; set; }
+        
+        public float? MinHeight { get; set; }
+        public float? MaxHeight { get; set; }
+
+        internal override ISpacePlan Measure(Size availableSpace)
+        {
+            if (MinWidth > availableSpace.Width + Size.Epsilon)
+                return new Wrap();
+            
+            if (MinHeight > availableSpace.Height + Size.Epsilon)
+                return new Wrap();
+            
+            var available = new Size(
+                MathHelpers.Min(MaxWidth, availableSpace.Width),
+                MathHelpers.Min(MaxHeight, availableSpace.Height));
+
+            var measurement = Child?.Measure(available) ?? new FullRender(Size.Zero);
+            var size = measurement as Size;
+
+            if (measurement is Wrap)
+                return new Wrap();
+            
+            var actualSize = new Size(
+                MathHelpers.Max(MinWidth, size.Width),
+                MathHelpers.Max(MinHeight, size.Height));
+            
+            if (size is FullRender)
+                return new FullRender(actualSize);
+            
+            if (size is PartialRender)
+                return new PartialRender(actualSize);
+            
+            throw new NotSupportedException();
+        }
+        
+        internal override void Draw(ICanvas canvas, Size availableSpace)
+        {
+            var available = new Size(
+                MathHelpers.Min(MaxWidth, availableSpace.Width),
+                MathHelpers.Min(MaxHeight, availableSpace.Height));
+            
+            Child?.Draw(canvas, available);
+        }
+    }
+    
+    static class MathHelpers
+    {
+        public static float Min(params float?[] values)
+        {
+            return values.Where(x => x.HasValue).Min().Value;
+        }
+        
+        public static float Max(params float?[] values)
+        {
+            return values.Where(x => x.HasValue).Max().Value;
+        }
+    }
+}

QuestPDF/Elements/Debug.cs

@@ -5,7 +5,7 @@ using SkiaSharp;
 
 namespace QuestPDF.Elements
 {
-    internal class DebugArea : IComponent
+    internal class Debug : IComponent
     {
         public IElement? Child { get; set; }
         
@@ -27,13 +27,10 @@ namespace QuestPDF.Elements
                         .Layer()
                         .ShowIf(!string.IsNullOrWhiteSpace(Text))
                         .AlignCenter()
-                        .MinimalBox()
+                        .Box()
                         .Background(Colors.White)
                         .Padding(2)
-                        .Text(Text)
-                        .FontColor(Color)
-                        .FontFamily(Fonts.Consolas)
-                        .FontSize(8);
+                        .Text(Text, TextStyle.Default.Color(Color).FontType("Consolas").Size(8));
                 });
         }
     }

QuestPDF/Elements/Decoration.cs

@@ -0,0 +1,85 @@
+using System;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Fluent;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Elements
+{
+    internal enum DecorationType
+    {
+        Prepend,
+        Append
+    }
+    
+    internal class SimpleDecoration : Element
+    {
+        public Element DecorationElement { get; set; } = Empty.Instance;
+        public Element ContentElement { get; set; } = Empty.Instance;
+        public DecorationType Type { get; set; } 
+
+        internal override ISpacePlan Measure(Size availableSpace)
+        {
+            var decorationMeasure = DecorationElement?.Measure(availableSpace);
+            
+            if (decorationMeasure is Wrap || decorationMeasure is PartialRender)
+                return new Wrap();
+
+            var decorationSize = decorationMeasure as Size ?? Size.Zero;
+            var contentMeasure = ContentElement?.Measure(new Size(availableSpace.Width, availableSpace.Height - decorationSize.Height)) ?? new FullRender(Size.Zero);
+            
+            if (contentMeasure is Wrap)
+                return new Wrap();
+
+            var contentSize = contentMeasure as Size ?? Size.Zero;
+            var resultSize = new Size(availableSpace.Width, decorationSize.Height + contentSize.Height);
+            
+            if (contentSize is PartialRender)
+                return new PartialRender(resultSize);
+            
+            if (contentSize is FullRender)
+                return new FullRender(resultSize);
+            
+            throw new NotSupportedException();
+        }
+
+        internal override void Draw(ICanvas canvas, 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 drawContent = () => ContentElement?.Draw(canvas, 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));
+            second();
+            canvas.Translate(new Position(0, -translateHeight));
+        }
+    }
+    
+    internal class Decoration : IComponent
+    {
+        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.Element(new SimpleDecoration
+            {
+                Type = DecorationType.Prepend,
+                DecorationElement = Header,
+                ContentElement = new SimpleDecoration
+                {
+                    Type = DecorationType.Append,
+                    ContentElement = Content,
+                    DecorationElement = Footer
+                }
+            });
+        }
+    }
+}

QuestPDF/Elements/DynamicImage.cs

@@ -0,0 +1,32 @@
+using System;
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Infrastructure;
+using SkiaSharp;
+
+namespace QuestPDF.Elements
+{
+    internal class DynamicImage : Element
+    {
+        public Func<Size, byte[]>? Source { get; set; }
+        
+        internal override ISpacePlan Measure(Size availableSpace)
+        {
+            return new FullRender(availableSpace.Width, availableSpace.Height);
+        }
+
+        internal override void Draw(ICanvas canvas, Size availableSpace)
+        {
+            var imageData = Source?.Invoke(availableSpace);
+            
+            if (imageData == null)
+                return;
+
+            var imageElement = new Image
+            {
+                InternalImage = SKImage.FromEncodedData(imageData)
+            };
+            
+            imageElement.Draw(canvas, availableSpace);
+        }
+    }
+}

QuestPDF/Elements/Empty.cs

@@ -0,0 +1,20 @@
+using QuestPDF.Drawing.SpacePlan;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Elements
+{
+    internal class Empty : Element
+    {
+        internal static Empty Instance { get; } = new Empty();
+        
+        internal override ISpacePlan Measure(Size availableSpace)
+        {
+            return new FullRender(Size.Zero);
+        }
+
+        internal override void Draw(ICanvas canvas, Size availableSpace)
+        {
+            
+        }
+    }
+}

QuestPDF/Elements/EnsureSpace.cs

@@ -1,19 +1,19 @@
-using QuestPDF.Drawing;
+using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Elements
 {
-    internal class EnsureSpace : ContainerElement, ICacheable
+    internal class EnsureSpace : ContainerElement
     {
         public const float DefaultMinHeight = 150;
         public float MinHeight { get; set; } = DefaultMinHeight;
 
-        internal override SpacePlan Measure(Size availableSpace)
+        internal override ISpacePlan Measure(Size availableSpace)
         {
             var measurement = base.Measure(availableSpace);
 
-            if (measurement.Type == SpacePlanType.PartialRender && availableSpace.Height < MinHeight)
-                return SpacePlan.Wrap();
+            if (measurement is PartialRender && availableSpace.Height < MinHeight)
+                return new Wrap();
 
             return measurement;
         }

QuestPDF/Elements/Extend.cs

@@ -1,28 +1,28 @@
 using System;
-using QuestPDF.Drawing;
+using QuestPDF.Drawing.SpacePlan;
 using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Elements
 {
-    internal class Extend : ContainerElement, ICacheable
+    internal class Extend : ContainerElement
     {
         public bool ExtendVertical { get; set; }
         public bool ExtendHorizontal { get; set; }
         
-        internal override SpacePlan Measure(Size availableSpace)
+        internal override ISpacePlan Measure(Size availableSpace)
         {
-            var childSize = base.Measure(availableSpace);
+            var childSize = Child?.Measure(availableSpace) ?? new FullRender(Size.Zero);
 
-            if (childSize.Type == SpacePlanType.Wrap)
+            if (childSize is Wrap)
                 return childSize;
             
-            var targetSize = GetTargetSize(availableSpace, childSize);
+            var targetSize = GetTargetSize(availableSpace, childSize as Size);
             
-            if (childSize.Type == SpacePlanType.PartialRender)
-                return SpacePlan.PartialRender(targetSize);
+            if (childSize is PartialRender)
+                return new PartialRender(targetSize);
             
-            if (childSize.Type == SpacePlanType.FullRender)
-                return SpacePlan.FullRender(targetSize);
+            if (childSize is FullRender)
+                return new FullRender(targetSize);
             
             throw new NotSupportedException();
         }

QuestPDF/Elements/ExternalLink.cs

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

QuestPDF/Elements/Grid.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using QuestPDF.Fluent;
 using QuestPDF.Infrastructure;
+using static QuestPDF.Infrastructure.HorizontalAlignment;
 
 namespace QuestPDF.Elements
 {
@@ -15,11 +16,11 @@ namespace QuestPDF.Elements
     {
         public const int DefaultColumnsCount = 12;
         
-        public List<GridElement> Children { get; } = new List<GridElement>();
+        public List<GridElement> Children { get; set; } = new List<GridElement>();
         public Queue<GridElement> ChildrenQueue { get; set; } = new Queue<GridElement>();
         public int ColumnsCount { get; set; } = DefaultColumnsCount;
 
-        public HorizontalAlignment Alignment { get; set; } = HorizontalAlignment.Left;
+        public HorizontalAlignment Alignment { get; set; } = Left;
         public float VerticalSpacing { get; set; } = 0;
         public float HorizontalSpacing { get; set; } = 0;
         
@@ -27,12 +28,12 @@ namespace QuestPDF.Elements
         {
             ChildrenQueue = new Queue<GridElement>(Children);
             
-            container.Column(column =>
+            container.Stack(stack =>
             {
-                column.Spacing(VerticalSpacing);
+                stack.Spacing(VerticalSpacing);
                 
                 while (ChildrenQueue.Any())
-                    column.Item().Row(BuildRow);
+                    stack.Item().Row(BuildRow);
             });
         }
         
@@ -61,16 +62,16 @@ namespace QuestPDF.Elements
             var emptySpace = ColumnsCount - columnsWidth;
             var hasEmptySpace = emptySpace >= Size.Epsilon;
 
-            if (Alignment == HorizontalAlignment.Center)
+            if (Alignment == Center)
                 emptySpace /= 2;
             
-            if (hasEmptySpace && Alignment != HorizontalAlignment.Left)
-                row.RelativeItem(emptySpace);
+            if (hasEmptySpace && Alignment != Left)
+                row.RelativeColumn(emptySpace);
                 
-            elements.ForEach(x => row.RelativeItem(x.Columns).Element(x.Child));
+            elements.ForEach(x => row.RelativeColumn(x.Columns).Element(x.Child));
 
-            if (hasEmptySpace && Alignment != HorizontalAlignment.Right)
-                row.RelativeItem(emptySpace);
+            if (hasEmptySpace && Alignment != Right)
+                row.RelativeColumn(emptySpace);
         }
     }
 }