Merge branch 'main' into feature/image-generation-settings

* Added library license validation check with a detailed description

* Improved license-related message

* Adjusted license information

* Updated nuget license

* Improved grammar

* License message: added link to license configuration

* Fixed build

.github/workflows/qodana.yml

@@ -0,0 +1,19 @@
+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.md

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

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

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

@@ -0,0 +1,23 @@
+# 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.

README.md

@@ -9,14 +9,15 @@
 [![GitHub Repo stars](https://img.shields.io/github/stars/QuestPDF/QuestPDF?style=for-the-badge)](https://github.com/QuestPDF/QuestPDF/stargazers)
 [![Nuget version](https://img.shields.io/nuget/v/QuestPdf?style=for-the-badge)](https://www.nuget.org/packages/QuestPDF/)
 [![Nuget download](https://img.shields.io/nuget/dt/QuestPDF?style=for-the-badge)](https://www.nuget.org/packages/QuestPDF/)
-[![License](https://img.shields.io/github/license/QuestPDF/QuestPDF?style=for-the-badge)](https://github.com/QuestPDF/QuestPDF/blob/main/LICENSE)
+[![QuestPDF License](https://img.shields.io/badge/LICENSE%20details-Community%20MIT%20and%20professional-green?style=for-the-badge)](https://www.questpdf.com/pricing.html#license)
 
 <br />
 
+
 ### QuestPDF is a modern open-source .NET library for PDF document generation. Offering comprehensive layout engine powered by concise and discoverable C# Fluent API.
 
 <img src="https://github.com/QuestPDF/QuestPDF-Documentation/blob/main/docs/public/previewer/animation.gif?raw=true" width="100%">
-
+ 
 <table>
 <tr>
     <td>👨‍💻</td>
@@ -48,13 +49,14 @@
 
 <br />
 
+
 ## Please help by giving a star
 
 Choosing a project dependency could be difficult. We need to ensure stability and maintainability of our projects. Surveys show that GitHub stars count play an important factor when assessing library quality. 
 
 ⭐ Please give this repository a star. It takes seconds and help thousands of developers! ⭐
 
-<img src="https://user-images.githubusercontent.com/9263853/224511996-9dd27a99-bef8-4d5e-bc14-9f6cfe0f5191.png" width="800" />
+<img src="https://user-images.githubusercontent.com/9263853/236193691-efb9cff8-e919-4826-9720-dcfb492980ae.png" width="800" />
 
 
 ## Please share with the community
@@ -68,6 +70,7 @@ As an open-source project without funding, I cannot afford advertising QuestPDF
 
 <br />
 
+
 ## Let's get started
 
 Begin exploring the QuestPDF library today. You are 250 lines of C# code away from creating a fully functional PDF invoice implementation.
@@ -80,6 +83,21 @@ Read the Getting Started tutorial to familiarize yourself with general library a
 
 <br />
 
+
+## Library 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.
+
+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.
+
+If you still want to support library development, please consider purchasing the Professional License.
+
+[![Library license details](https://img.shields.io/badge/%F0%9F%93%9C%0A%20read-license%20details-blue?style=for-the-badge)](https://www.questpdf.com/pricing.html#license)
+[![Library pricing details](https://img.shields.io/badge/%F0%9F%92%8E%20read-pricing%20details-green?style=for-the-badge)](https://www.questpdf.com/pricing.html#tiers)
+
+<br />
+
+
 ## QuestPDF on JetBrains OSS Power-Ups
 
 QuestPDF was presented on one of the episodes of OSS Power-Ups hosted by JetBrains. Huge thanks for Matthias Koch and entire JetBrains team for giving me a chance to show QuestPDF. You are the best!
@@ -88,5 +106,4 @@ QuestPDF was presented on one of the episodes of OSS Power-Ups hosted by JetBrai
     <img src="https://github.com/QuestPDF/QuestPDF-Documentation/blob/main/docs/public/jetbrains-oss-powerups-youtube.png?raw=true" width="600px">
 </a>
 
-
 [![YouTube video about QuestPDF]( https://img.shields.io/badge/watch%20on-YouTube-red?logo=youtube&style=for-the-badge)](https://www.youtube.com/watch?v=-iYvZvpLX0g)

Source/QuestPDF.Examples/Engine/SimpleDocument.cs

@@ -13,25 +13,22 @@ namespace QuestPDF.Examples.Engine
         
         private Action<IDocumentContainer> Content { get; }
         private int MaxPages { get; }
-        private bool ApplyCaching { get; }
-        private bool ApplyDebugging { get; }
 
         public SimpleDocument(Action<IDocumentContainer> content, int maxPages, bool applyCaching, bool applyDebugging)
         {
             Content = content;
             MaxPages = maxPages;
-            ApplyCaching = applyCaching;
-            ApplyDebugging = applyDebugging;
+
+            QuestPDF.Settings.EnableCaching = applyCaching;
+            QuestPDF.Settings.EnableDebugging = applyDebugging;
+            QuestPDF.Settings.DocumentLayoutExceptionThreshold = MaxPages;
         }
         
-        public DocumentMetadata GetMetadata()
+        public DocumentSettings GetSettings()
         {
-            return new DocumentMetadata()
+            return new DocumentSettings()
             {
-                RasterDpi = PageSizes.PointsPerInch * ImageScalingFactor,
-                DocumentLayoutExceptionThreshold = MaxPages,
-                ApplyCaching = ApplyCaching,
-                ApplyDebugging = ApplyDebugging
+                ImageRasterDpi = PageSizes.PointsPerInch * ImageScalingFactor
             };
         }
         

Source/QuestPDF.Examples/ImageExamples.cs

@@ -1,10 +1,12 @@
 using System;
 using System.IO;
+using System.Linq;
 using NUnit.Framework;
 using QuestPDF.Drawing.Exceptions;
 using QuestPDF.Examples.Engine;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
 
 namespace QuestPDF.Examples
 {
@@ -50,6 +52,92 @@ namespace QuestPDF.Examples
                 });
         }
         
+        [Test]
+        public void ScalingImageWithAlpha()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(PageSizes.A4)
+                .ProducePdf()
+                .ShowResults()
+                .Render(page =>
+                {
+                    page.Padding(25).Layers(layers =>
+                    {
+                        layers.Layer().Image(Placeholders.Image);
+                        layers.PrimaryLayer().Padding(25).Image("multilingual.png");
+                    });
+                });
+        }
+
+        [Test]
+        public void DpiSetting()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(400, 600)
+                .ProduceImages()
+                .ShowResults()
+                .Render(page =>
+                {
+                    page.Padding(15).Column(column =>
+                    {
+                        column.Spacing(15);
+                        
+                        column.Item().Image("photo.jpg").WithRasterDpi(16).FitUnproportionally();
+                        column.Item().Image("photo.jpg").WithRasterDpi(72);
+                    });
+                });
+        }
+        
+        [Test]
+        public void CompressionSetting()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(400, 600)
+                .ProduceImages()
+                .ShowResults()
+                .Render(page =>
+                {
+                    page.Padding(15).Column(column =>
+                    {
+                        column.Spacing(15);
+                        
+                        column.Item().Image("photo.jpg").WithCompressionQuality(ImageCompressionQuality.VeryLow).WithRasterDpi(72);
+                        column.Item().Image("photo.jpg").WithCompressionQuality(ImageCompressionQuality.High).WithRasterDpi(72);
+                    });
+                });
+        }
+        
+        [Test]
+        public void ReusingImage_With()
+        {
+            RenderingTest
+                .Create()
+                .PageSize(400, 600)
+                .ProduceImages()
+                .ShowResults()
+                .Render(page =>
+                {
+                    page.Padding(15).Column(column =>
+                    {
+                        column.Spacing(15);
+
+                        var image = Image.FromFile("checkbox.png");
+                        
+                        foreach (var i in Enumerable.Range(0, 5))
+                        {
+                            column.Item().Row(row =>
+                            {
+                                row.AutoItem().Width(24).Image(image);
+                                row.RelativeItem().PaddingLeft(8).AlignMiddle().Text(Placeholders.Label()).FontSize(16);
+                            });
+                        }
+                    });
+                });
+        }
+        
         [Test]
         public void Exception()
         {

Source/QuestPDF.Examples/LicenseSetup.cs

@@ -0,0 +1,15 @@
+using NUnit.Framework;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.Examples
+{
+    [SetUpFixture]
+    public class LicenseSetup
+    {
+        [OneTimeSetUp]
+        public static void Setup()
+        {
+            QuestPDF.Settings.License = LicenseType.Community;
+        }
+    }
+}

Source/QuestPDF.Examples/QuestPDF.Examples.csproj

@@ -32,6 +32,15 @@
       <None Update="pdf-icon.svg">
         <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
       </None>
+      <None Update="multilingual.png">
+        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      </None>
+      <None Update="photo.jpg">
+        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      </None>
+      <None Update="checkbox.png">
+        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      </None>
     </ItemGroup>
 
 </Project>

Source/QuestPDF.Examples/TableExamples.cs

@@ -316,6 +316,58 @@ namespace QuestPDF.Examples
                 });
         }
         
+        [Test]
+        public void Bug_RowSpanWorksIncorrectly()
+        {
+            // https://github.com/QuestPDF/QuestPDF/issues/552
+            
+            RenderingTest
+                .Create()
+                .ProduceImages()
+                .PageSize(PageSizes.A5.Landscape())
+                .ShowResults()
+                .Render(container =>
+                {
+                    container.Padding(20).Table(table => 
+                    {
+                        table.ColumnsDefinition(columns => 
+                        {
+                            columns.RelativeColumn(1);
+                            columns.RelativeColumn(2);
+                            columns.RelativeColumn(2);
+                            columns.RelativeColumn(2);
+                        });
+
+                        foreach (var i in Enumerable.Range(6, 9))
+                        {
+                            table.Cell().Element(CellStyleMainTable).Text($"{i:00}:00");
+                            
+                            foreach (var j in Enumerable.Range(1, 3))
+                                table.Cell().Element(CellStyleMainTable).Text("");
+                        }
+
+                        static IContainer CellStyleMainTable(IContainer container) 
+                        {
+                            return container
+                                .Border(0.5f).BorderColor(Colors.Blue.Lighten4)
+                                .Background(Colors.Blue.Lighten5)
+                                .PaddingVertical(5);
+                        }
+
+                        table.Cell().Row(1).RowSpan(3).Column(2).Element(BlockAccepted).Text("3 rows");
+                        table.Cell().Row(1).RowSpan(6).Column(3).Element(BlockAccepted).Text("6 rows");
+                        table.Cell().Row(3).RowSpan(5).Column(4).Element(BlockAccepted).Text("5 rows");
+                        
+                        static IContainer BlockAccepted(IContainer container)
+                        {
+                            return container
+                                .Border(1.5f).BorderColor(Colors.Green.Lighten2)
+                                .Background(Colors.Green.Lighten4);
+                        }
+                    });
+                });
+        }
+        
         [Test]
         public void TableHeader()
         {

Source/QuestPDF.Previewer/QuestPDF.Previewer.csproj

@@ -4,11 +4,10 @@
         <Authors>MarcinZiabek</Authors>
         <Company>CodeFlint</Company>
         <PackageId>QuestPDF.Previewer</PackageId>
-        <Version>2022.12.0</Version>
+        <Version>2023.5.0</Version>
         <PackAsTool>true</PackAsTool>
         <ToolCommandName>questpdf-previewer</ToolCommandName>
         <PackageDescription>QuestPDF is an open-source, modern and battle-tested library that can help you with generating PDF documents by offering friendly, discoverable and predictable C# fluent API.</PackageDescription>
-        <PackageReleaseNotes>Initial release.</PackageReleaseNotes>
         <LangVersion>10</LangVersion>
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
         <PackageIcon>Logo.png</PackageIcon>
@@ -18,10 +17,8 @@
         <RepositoryUrl>https://github.com/QuestPDF/library.git</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
         <Copyright>Marcin Ziąbek, QuestPDF contributors</Copyright>
-        <PackageTags>pdf report file export generate generation tool create creation render portable document format quest html library converter open source free standard core previewer</PackageTags>
+        <PackageTags>previewer pdf report file export generate generation tool create creation render portable document format quest html library converter open source free standard core</PackageTags>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
-        <IncludeSymbols>true</IncludeSymbols>
-        <SymbolPackageFormat>snupkg</SymbolPackageFormat>
         <OutputType>exe</OutputType>
         <TargetFramework>net6.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
@@ -40,12 +37,12 @@
     
     <ItemGroup>
         <FrameworkReference Include="Microsoft.AspNetCore.App" />
-        <PackageReference Include="Avalonia" Version="0.10.18" />
-        <PackageReference Include="Avalonia.Desktop" Version="0.10.18" />
-        <PackageReference Include="Avalonia.Diagnostics" Version="0.10.18" />
+        <PackageReference Include="Avalonia" Version="0.10.19" />
+        <PackageReference Include="Avalonia.Desktop" Version="0.10.19" />
+        <PackageReference Include="Avalonia.Diagnostics" Version="0.10.19" />
         <PackageReference Include="Avalonia.Markup.Xaml.Loader" Version="0.10.18" />
-        <PackageReference Include="Avalonia.ReactiveUI" Version="0.10.18" />
-        <PackageReference Include="ReactiveUI" Version="18.4.1" />
+        <PackageReference Include="Avalonia.ReactiveUI" Version="0.10.19" />
+        <PackageReference Include="ReactiveUI" Version="18.4.44" />
         <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="2.88.3" />
         <PackageReference Include="SkiaSharp.NativeAssets.Win32" Version="2.88.3" />
         <PackageReference Include="SkiaSharp.NativeAssets.macOS" Version="2.88.3" />

Source/QuestPDF.ReportSample/Tests.cs

@@ -17,26 +17,24 @@ namespace QuestPDF.ReportSample
         [SetUp]
         public void SetUp()
         {
+            QuestPDF.Settings.License = LicenseType.Community;
+            
             var model = DataSource.GetReport();
             Report = new StandardReport(model);
-        }
-        
-        [Test] 
-        public void GenerateAndShowPdf()
-        {
+            
             //ImagePlaceholder.Solid = true;
-        
-            var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"test_result.pdf");
-            Report.GeneratePdf(path);
-            Process.Start("explorer.exe", path);
         }
         
         [Test] 
-        public void GenerateAndShowXps()
+        public void GeneratePdfAndShow()
         {
-            var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"test_result.xps");
-            Report.GenerateXps(path);
-            Process.Start("explorer.exe", path);
+            Report.GeneratePdfAndShow();
+        }
+        
+        [Test] 
+        public void GenerateXpsAndShow()
+        {
+            Report.GenerateXpsAndShow();
         }
     }
 }

Source/QuestPDF.UnitTests/DynamicImageTests.cs

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

Source/QuestPDF.UnitTests/ImageTests.cs

@@ -1,10 +1,18 @@
-using NUnit.Framework;
+using System;
+using System.IO;
+using System.Linq;
+using System.Net.Mime;
+using FluentAssertions;
+using NUnit.Framework;
 using QuestPDF.Drawing;
 using QuestPDF.Elements;
 using QuestPDF.Fluent;
+using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
 using QuestPDF.UnitTests.TestEngine;
 using SkiaSharp;
+using ImageElement = QuestPDF.Elements.Image;
+using DocumentImage = QuestPDF.Infrastructure.Image;
 
 namespace QuestPDF.UnitTests
 {
@@ -15,9 +23,9 @@ namespace QuestPDF.UnitTests
         public void Measure_TakesAvailableSpaceRegardlessOfSize()
         {
             TestPlan
-                .For(x => new Image
+                .For(x => new ImageElement
                 {
-                    InternalImage = GenerateImage(400, 300)
+                    DocumentImage = GenerateDocumentImage(400, 300)
                 })
                 .MeasureElement(new Size(300, 200))
                 .CheckMeasureResult(SpacePlan.FullRender(300, 200));
@@ -27,9 +35,11 @@ namespace QuestPDF.UnitTests
         public void Draw_TakesAvailableSpaceRegardlessOfSize()
         {
             TestPlan
-                .For(x => new Image
+                .For(x => new ImageElement
                 {
-                    InternalImage = GenerateImage(400, 300)
+                    CompressionQuality = ImageCompressionQuality.High,
+                    TargetDpi = DocumentSettings.DefaultRasterDpi,
+                    DocumentImage = GenerateDocumentImage(400, 300)
                 })
                 .DrawElement(new Size(300, 200))
                 .ExpectCanvasDrawImage(new Position(0, 0), new Size(300, 200))
@@ -39,7 +49,7 @@ namespace QuestPDF.UnitTests
         [Test]
         public void Fluent_RecognizesImageProportions()
         {
-            var image = GenerateImage(600, 200).Encode(SKEncodedImageFormat.Png, 100).ToArray();
+            var image = GenerateDocumentImage(600, 200);
             
             TestPlan
                 .For(x =>
@@ -52,11 +62,80 @@ namespace QuestPDF.UnitTests
                 .CheckMeasureResult(SpacePlan.FullRender(300, 100));;
         }
         
-        SKImage GenerateImage(int width, int height)
+        [Test]
+        public void UsingSharedImageShouldNotDrasticallyIncreaseDocumentSize()
         {
-            var imageInfo = new SKImageInfo(width, height);
-            using var surface = SKSurface.Create(imageInfo);
-            return surface.Snapshot();
+            var photo = File.ReadAllBytes("Resources/photo.jpg");
+
+            var documentWithSingleImageSize = GetDocumentSize(container =>
+            {
+                container.Image(photo);
+            });
+
+            var documentWithMultipleImagesSize = GetDocumentSize(container =>
+            {
+                container.Column(column =>
+                {
+                    foreach (var i in Enumerable.Range(0, 10))
+                        column.Item().Image(photo);
+                });
+            });
+
+            var documentWithSingleImageUsedMultipleTimesSize = GetDocumentSize(container =>
+            {
+                container.Column(column =>
+                {
+                    var sharedImage = DocumentImage.FromBinaryData(photo);
+                    
+                    foreach (var i in Enumerable.Range(0, 10))
+                        column.Item().Image(sharedImage);
+                });
+            });
+
+            (documentWithMultipleImagesSize / (float)documentWithSingleImageSize).Should().BeInRange(9.9f, 10);
+            (documentWithSingleImageUsedMultipleTimesSize / (float)documentWithSingleImageSize).Should().BeInRange(1f, 1.05f);
+        }
+        
+        [Test]
+        public void ImageCompressionHasImpactOnDocumentSize()
+        {
+            var photo = File.ReadAllBytes("Resources/photo.jpg");
+
+            var veryLowCompressionSize = GetDocumentSize(container => container.Image(photo).WithCompressionQuality(ImageCompressionQuality.VeryLow));
+            var bestCompressionSize = GetDocumentSize(container => container.Image(photo).WithCompressionQuality(ImageCompressionQuality.Best));
+
+            (bestCompressionSize / (float)veryLowCompressionSize).Should().BeGreaterThan(25);
+        }
+        
+        [Test]
+        public void TargetDpiHasImpactOnDocumentSize()
+        {
+            var photo = File.ReadAllBytes("Resources/photo.jpg");
+            
+            var lowDpiSize = GetDocumentSize(container => container.Image(photo).WithRasterDpi(12));
+            var highDpiSize = GetDocumentSize(container => container.Image(photo).WithRasterDpi(144));
+
+            (highDpiSize / (float)lowDpiSize).Should().BeGreaterThan(40);
+        }
+
+        private static int GetDocumentSize(Action<IContainer> container)
+        {
+            return Document
+                .Create(document =>
+                {
+                    document.Page(page =>
+                    {
+                        page.Content().Element(container);
+                    });
+                })
+                .GeneratePdf()
+                .Length;
+        }
+
+        DocumentImage GenerateDocumentImage(int width, int height)
+        {
+            var image = Placeholders.Image(width, height);
+            return DocumentImage.FromBinaryData(image);
         }
     }
 }

Source/QuestPDF.UnitTests/LicenseSetup.cs

@@ -0,0 +1,15 @@
+using NUnit.Framework;
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF.UnitTests
+{
+    [SetUpFixture]
+    public class LicenseSetup
+    {
+        [OneTimeSetUp]
+        public static void Setup()
+        {
+            QuestPDF.Settings.License = LicenseType.Community;
+        }
+    }
+}

Source/QuestPDF.UnitTests/QuestPDF.UnitTests.csproj

@@ -27,4 +27,10 @@
       </EmbeddedResource>
     </ItemGroup>
 
+    <ItemGroup>
+      <None Update="Resources\photo.jpg">
+        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      </None>
+    </ItemGroup>
+
 </Project>

Source/QuestPDF.UnitTests/TestEngine/TestPlan.cs

@@ -237,6 +237,8 @@ namespace QuestPDF.UnitTests.TestEngine
                 
                 Child = new DynamicImage
                 {
+                    CompressionQuality = ImageCompressionQuality.Medium,
+                    TargetDpi = DocumentSettings.DefaultRasterDpi,
                     Source = Placeholders.Image
                 }
             };

Source/QuestPDF/Drawing/DocumentGenerator.cs

@@ -17,20 +17,23 @@ namespace QuestPDF.Drawing
     {
         internal static void GeneratePdf(Stream stream, IDocument document)
         {
+            ValidateLicense();
             CheckIfStreamIsCompatible(stream);
             
             var metadata = document.GetMetadata();
-            var canvas = new PdfCanvas(stream, metadata);
-            RenderDocument(canvas, document);
+            var settings = document.GetSettings();
+            var canvas = new PdfCanvas(stream, metadata, settings);
+            RenderDocument(canvas, document, settings);
         }
         
         internal static void GenerateXps(Stream stream, IDocument document)
         {
+            ValidateLicense();
             CheckIfStreamIsCompatible(stream);
             
-            var metadata = document.GetMetadata();
-            var canvas = new XpsCanvas(stream, metadata);
-            RenderDocument(canvas, document);
+            var settings = document.GetSettings();
+            var canvas = new XpsCanvas(stream, settings);
+            RenderDocument(canvas, document, settings);
         }
 
         private static void CheckIfStreamIsCompatible(Stream stream)
@@ -42,30 +45,64 @@ namespace QuestPDF.Drawing
                 throw new ArgumentException("The library requires a Stream object with the 'seek' capability available (the CanSeek flag). Please consider using the MemoryStream class.");
         }
         
-        internal static ICollection<byte[]> GenerateImages(IDocument document)
+        internal static ICollection<byte[]> GenerateImages(IDocument document, ImageGenerationSettings settings)
         {
-            var metadata = document.GetMetadata();
-            var canvas = new ImageCanvas(metadata);
-            RenderDocument(canvas, document);
+            ValidateLicense();
+            
+            var documentSettings = document.GetSettings();
+            documentSettings.ImageRasterDpi = settings.RasterDpi;
+            var canvas = new ImageCanvas(settings);
+            RenderDocument(canvas, document, documentSettings, useOriginalImages: true);
 
             return canvas.Images;
         }
 
+        private static void ValidateLicense()
+        {
+            if (Settings.License.HasValue)
+                return;
+            
+            var newParagraph = Environment.NewLine + Environment.NewLine;
+
+            var exceptionMessage = 
+                $"QuestPDF is a modern open-source library. " +
+                $"We identify the importance of the library in your projects and therefore want to make sure you can safely and confidently continue the development. " +
+                $"Being a healthy and growing community is the primary goal that motivates us to pursue professionalism. {newParagraph}" +
+                $"We love and highly appreciate the .NET Community, and therefore the vast majority of users are welcome to use the library completely for free under the QuestPDF Community MIT license. {newParagraph}" +
+                $"However, 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 the number of software developers. {newParagraph}" +
+                $"If you still want to support library development, please consider purchasing the Professional License. {newParagraph}" +
+                $"For evaluation purposes, feel free to use the QuestPDF Community License in a non-production environment. {newParagraph}" +
+                $"Please refer to the QuestPDF License and Pricing webpage for more details. (https://www.questpdf.com/pricing.html) {newParagraph}" +
+                $"If you are an existing QuestPDF user and for any reason cannot update, you can stay with the 2022.12.X release with the extended quality support but without any new features, improvements, or optimizations. That release will always be available under the MIT license, free for commercial usage. {newParagraph}" +
+                $"The library does not require any license key. " +
+                $"We trust our users, and therefore the process is simple. " +
+                $"To disable license validation and turn off this exception, please configure an eligible license using the QuestPDF.Settings.License API, for example: {newParagraph}" +
+                $"\"QuestPDF.Settings.License = LicenseType.Community;\" {newParagraph}" +
+                $"Learn more on: https://www.questpdf.com/license-configuration.html {newParagraph}";
+            
+            throw new Exception(exceptionMessage)
+            {
+                HelpLink = "https://www.questpdf.com/pricing.html"
+            };
+        }
+
         internal static ICollection<PreviewerPicture> GeneratePreviewerPictures(IDocument document)
         {
             var canvas = new SkiaPictureCanvas();
-            RenderDocument(canvas, document);
+            RenderDocument(canvas, document, DocumentSettings.Default);
             return canvas.Pictures;
         }
         
-        internal static void RenderDocument<TCanvas>(TCanvas canvas, IDocument document)
+        internal static void RenderDocument<TCanvas>(TCanvas canvas, IDocument document, DocumentSettings settings, bool useOriginalImages = false)
             where TCanvas : ICanvas, IRenderingCanvas
         {
             var container = new DocumentContainer();
             document.Compose(container);
             var content = container.Compose();
+            
             ApplyInheritedAndGlobalTexStyle(content, TextStyle.Default);
-            ApplyContentDirection(content, ContentDirection.LeftToRight);
+            ApplyContentDirection(content, settings.ContentDirection);
+            ApplyDefaultImageConfiguration(content, settings.ImageRasterDpi, settings.ImageCompressionQuality, useOriginalImages);
             
             var debuggingState = Settings.EnableDebugging ? ApplyDebugging(content) : null;
             
@@ -191,6 +228,41 @@ namespace QuestPDF.Drawing
             foreach (var child in content.GetChildren())
                 ApplyContentDirection(child, direction);
         }
+        
+        internal static void ApplyDefaultImageConfiguration(this Element? content, int imageRasterDpi, ImageCompressionQuality imageCompressionQuality, bool useOriginalImages)
+        {
+            content.VisitChildren(x =>
+            {
+                if (x is QuestPDF.Elements.Image image)
+                {
+                    image.TargetDpi ??= imageRasterDpi;
+                    image.CompressionQuality ??= imageCompressionQuality;
+                    image.UseOriginalImage |= useOriginalImages;
+                }
+
+                if (x is QuestPDF.Elements.DynamicImage dynamicImage)
+                {
+                    dynamicImage.TargetDpi ??= imageRasterDpi;
+                    dynamicImage.CompressionQuality ??= imageCompressionQuality;
+                    dynamicImage.UseOriginalImage |= useOriginalImages;
+                }
+
+                if (x is DynamicHost dynamicHost)
+                {
+                    dynamicHost.ImageTargetDpi ??= imageRasterDpi;
+                    dynamicHost.ImageCompressionQuality ??= imageCompressionQuality;
+                    dynamicHost.UseOriginalImage |= useOriginalImages;
+                }
+
+                if (x is TextBlock textBlock)
+                {
+                    foreach (var textBlockElement in textBlock.Items.OfType<TextBlockElement>())
+                    {
+                        textBlockElement.Element.ApplyDefaultImageConfiguration(imageRasterDpi, imageCompressionQuality, useOriginalImages);
+                    }
+                }
+            });
+        }
 
         internal static void ApplyInheritedAndGlobalTexStyle(this Element? content, TextStyle documentDefaultTextStyle)
         {
@@ -221,4 +293,4 @@ namespace QuestPDF.Drawing
                 ApplyInheritedAndGlobalTexStyle(child, documentDefaultTextStyle);
         }
     }
-}
+}

Source/QuestPDF/Drawing/ImageCanvas.cs

@@ -7,14 +7,14 @@ namespace QuestPDF.Drawing
 {
     internal class ImageCanvas : SkiaCanvasBase
     {
-        private DocumentMetadata Metadata { get; }
+        private ImageGenerationSettings Settings { get; }
         private SKSurface Surface { get; set; }
 
         internal ICollection<byte[]> Images { get; } = new List<byte[]>();
         
-        public ImageCanvas(DocumentMetadata metadata)
+        public ImageCanvas(ImageGenerationSettings settings)
         {
-            Metadata = metadata;
+            Settings = settings;
         }
         
         public override void BeginDocument()
@@ -30,7 +30,7 @@ namespace QuestPDF.Drawing
 
         public override void BeginPage(Size size)
         {
-            var scalingFactor = Metadata.RasterDpi / (float) PageSizes.PointsPerInch;
+            var scalingFactor = Settings.RasterDpi / (float) PageSizes.PointsPerInch;
             var imageInfo = new SKImageInfo((int) (size.Width * scalingFactor), (int) (size.Height * scalingFactor));
             
             Surface = SKSurface.Create(imageInfo);
@@ -42,7 +42,7 @@ namespace QuestPDF.Drawing
         public override void EndPage()
         {
             Canvas.Save();
-            var image = Surface.Snapshot().Encode(SKEncodedImageFormat.Png, 100).ToArray();
+            var image = Surface.Snapshot().Encode(Settings.ImageFormat.ToSkImageFormat(), Settings.ImageCompressionQuality.ToQualityValue()).ToArray();
             Images.Add(image);
             
             Canvas.Dispose();

Source/QuestPDF/Drawing/PdfCanvas.cs

@@ -2,23 +2,24 @@
 using System.IO;
 using QuestPDF.Drawing.Exceptions;
 using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
 using SkiaSharp;
 
 namespace QuestPDF.Drawing
 {
     internal class PdfCanvas : SkiaDocumentCanvasBase
     {
-        public PdfCanvas(Stream stream, DocumentMetadata documentMetadata) 
-            : base(CreatePdf(stream, documentMetadata))
+        public PdfCanvas(Stream stream, DocumentMetadata documentMetadata, DocumentSettings documentSettings) 
+            : base(CreatePdf(stream, documentMetadata, documentSettings))
         {
             
         }
 
-        private static SKDocument CreatePdf(Stream stream, DocumentMetadata documentMetadata)
+        private static SKDocument CreatePdf(Stream stream, DocumentMetadata documentMetadata, DocumentSettings documentSettings)
         {
             try
             {
-                return SKDocument.CreatePdf(stream, MapMetadata(documentMetadata));
+                return SKDocument.CreatePdf(stream, MapMetadata(documentMetadata, documentSettings));
             }
             catch (TypeInitializationException exception)
             {
@@ -26,7 +27,7 @@ namespace QuestPDF.Drawing
             }
         }
 
-        private static SKDocumentPdfMetadata MapMetadata(DocumentMetadata metadata)
+        private static SKDocumentPdfMetadata MapMetadata(DocumentMetadata metadata, DocumentSettings documentSettings)
         {
             return new SKDocumentPdfMetadata
             {
@@ -40,9 +41,9 @@ namespace QuestPDF.Drawing
                 Creation = metadata.CreationDate,
                 Modified = metadata.ModifiedDate,
                 
-                RasterDpi = metadata.RasterDpi,
-                EncodingQuality = metadata.ImageQuality,
-                PdfA = metadata.PdfA
+                RasterDpi = documentSettings.ImageRasterDpi,
+                EncodingQuality = documentSettings.ImageCompressionQuality.ToQualityValue(),
+                PdfA = documentSettings.PdfA
             };
         }
     }

Source/QuestPDF/Drawing/XpsCanvas.cs

@@ -2,23 +2,24 @@
 using System.IO;
 using QuestPDF.Drawing.Exceptions;
 using QuestPDF.Helpers;
+using QuestPDF.Infrastructure;
 using SkiaSharp;
 
 namespace QuestPDF.Drawing
 {
     internal class XpsCanvas : SkiaDocumentCanvasBase
     {
-        public XpsCanvas(Stream stream, DocumentMetadata documentMetadata) 
-            : base(CreateXps(stream, documentMetadata))
+        public XpsCanvas(Stream stream, DocumentSettings documentSettings) 
+            : base(CreateXps(stream, documentSettings))
         {
             
         }
         
-        private static SKDocument CreateXps(Stream stream, DocumentMetadata documentMetadata)
+        private static SKDocument CreateXps(Stream stream, DocumentSettings documentSettings)
         {
             try
             {
-                return SKDocument.CreateXps(stream, documentMetadata.RasterDpi);
+                return SKDocument.CreateXps(stream, documentSettings.ImageRasterDpi);
             }
             catch (TypeInitializationException exception)
             {

Source/QuestPDF/Elements/AspectRatio.cs

@@ -8,11 +8,14 @@ namespace QuestPDF.Elements
     {
         public ContentDirection ContentDirection { get; set; }
         
-        public float Ratio { get; set; } = 1;
+        public float Ratio { get; set; }
         public AspectRatioOption Option { get; set; } = AspectRatioOption.FitWidth;
         
         internal override SpacePlan Measure(Size availableSpace)
         {
+            if (Ratio == 0)
+                return SpacePlan.FullRender(0, 0);
+            
             if(Child == null)
                 return SpacePlan.FullRender(0, 0);
             
@@ -56,6 +59,9 @@ namespace QuestPDF.Elements
         
         private Size GetTargetSize(Size availableSpace)
         {
+            if (Ratio == 0)
+                return availableSpace;
+            
             var spaceRatio = availableSpace.Width / availableSpace.Height;
 
             var fitHeight = new Size(availableSpace.Height * Ratio, availableSpace.Height) ;

Source/QuestPDF/Elements/Dynamic.cs

@@ -14,6 +14,10 @@ namespace QuestPDF.Elements
         internal TextStyle TextStyle { get; set; } = TextStyle.Default;
         public ContentDirection ContentDirection { get; set; }
         
+        internal int? ImageTargetDpi { get; set; }
+        internal ImageCompressionQuality? ImageCompressionQuality { get; set; }
+        internal bool UseOriginalImage { get; set; }
+        
         public DynamicHost(DynamicComponentProxy child)
         {
             Child = child;
@@ -58,6 +62,10 @@ namespace QuestPDF.Elements
                 TextStyle = TextStyle,
                 ContentDirection = ContentDirection,
                 
+                ImageTargetDpi = ImageTargetDpi.Value,
+                ImageCompressionQuality = ImageCompressionQuality.Value,
+                UseOriginalImage = UseOriginalImage,
+                
                 PageNumber = PageContext.CurrentPage,
                 TotalPages = PageContext.GetLocation(Infrastructure.PageContext.DocumentLocation).PageEnd,
                 AvailableSize = availableSize
@@ -79,7 +87,11 @@ namespace QuestPDF.Elements
         
         internal TextStyle TextStyle { get; set; }
         internal ContentDirection ContentDirection { get; set; }
-    
+
+        internal int ImageTargetDpi { get; set; }
+        internal ImageCompressionQuality ImageCompressionQuality { get; set; }
+        internal bool UseOriginalImage { get; set; }
+        
         public int PageNumber { get; internal set; }
         public int TotalPages { get; internal set; }
         public Size AvailableSize { get; internal set; }
@@ -91,6 +103,7 @@ namespace QuestPDF.Elements
             
             container.ApplyInheritedAndGlobalTexStyle(TextStyle);
             container.ApplyContentDirection(ContentDirection);
+            container.ApplyDefaultImageConfiguration(ImageTargetDpi, ImageCompressionQuality, UseOriginalImage);
             
             container.InjectDependencies(PageContext, Canvas);
             container.VisitChildren(x => (x as IStateResettable)?.ResetState());

Source/QuestPDF/Elements/DynamicImage.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Security;
 using QuestPDF.Drawing;
 using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
@@ -6,9 +7,14 @@ using SkiaSharp;
 
 namespace QuestPDF.Elements
 {
+    public delegate byte[] GenerateDynamicImageDelegate(ImageSize size);
+    
     internal class DynamicImage : Element
     {
-        public Func<Size, byte[]>? Source { get; set; }
+        internal int? TargetDpi { get; set; }
+        internal ImageCompressionQuality? CompressionQuality { get; set; }
+        internal bool UseOriginalImage { get; set; }
+        public GenerateDynamicImageDelegate? Source { get; set; }
         
         internal override SpacePlan Measure(Size availableSpace)
         {
@@ -19,13 +25,34 @@ namespace QuestPDF.Elements
 
         internal override void Draw(Size availableSpace)
         {
-            var imageData = Source?.Invoke(availableSpace);
+            var targetResolution = GetTargetResolution(availableSpace, TargetDpi.Value);
+            var imageData = Source?.Invoke(targetResolution);
             
             if (imageData == null)
                 return;
 
-            using var image = SKImage.FromEncodedData(imageData);
-            Canvas.DrawImage(image, Position.Zero, availableSpace);
+            using var originalImage = SKImage.FromEncodedData(imageData);
+            
+            if (UseOriginalImage)
+            {
+                Canvas.DrawImage(originalImage, Position.Zero, availableSpace);
+                return;
+            }
+            
+            using var compressedImage = originalImage.CompressImage(CompressionQuality.Value);
+
+            var targetImage = Helpers.Helpers.GetImageWithSmallerSize(originalImage, compressedImage);
+            Canvas.DrawImage(targetImage, Position.Zero, availableSpace);
+        }
+
+        private static ImageSize GetTargetResolution(Size availableSize, int targetDpi)
+        {
+            var scalingFactor = targetDpi / (float)DocumentSettings.DefaultRasterDpi;
+
+            return new ImageSize(
+                (int)(availableSize.Width * scalingFactor),
+                (int)(availableSize.Height * scalingFactor)
+            );
         }
     }
-}
+}

Source/QuestPDF/Elements/Image.cs

@@ -7,11 +7,16 @@ namespace QuestPDF.Elements
 {
     internal class Image : Element, ICacheable
     {
-        public SKImage? InternalImage { get; set; }
+        public Infrastructure.Image? DocumentImage { get; set; }
+
+        internal bool UseOriginalImage { get; set; }
+        internal int? TargetDpi { get; set; }
+        internal ImageCompressionQuality? CompressionQuality { get; set; }
 
         ~Image()
         {
-            InternalImage?.Dispose();
+            if (DocumentImage is { IsDocumentScoped: true })
+                DocumentImage?.Dispose();
         }
         
         internal override SpacePlan Measure(Size availableSpace)
@@ -23,10 +28,44 @@ namespace QuestPDF.Elements
 
         internal override void Draw(Size availableSpace)
         {
-            if (InternalImage == null)
+            if (DocumentImage == null)
                 return;
 
-            Canvas.DrawImage(InternalImage, Position.Zero, availableSpace);
+            var image = GetImageToDraw(availableSpace);
+            Canvas.DrawImage(image, Position.Zero, availableSpace);
+        }
+
+        private SKImage GetImageToDraw(Size availableSpace)
+        {
+            var originalImage = DocumentImage.SkImage;
+            
+            if (UseOriginalImage)
+                return originalImage;
+            
+            var request = new GetImageVersionRequest
+            {
+                Resolution = GetTargetResolution(DocumentImage.Size, availableSpace, TargetDpi.Value),
+                CompressionQuality = CompressionQuality.Value
+            };
+            
+            var targetImage = DocumentImage.GetVersionOfSize(request);
+            return Helpers.Helpers.GetImageWithSmallerSize(originalImage, targetImage);
+        }
+        
+        private static ImageSize GetTargetResolution(ImageSize imageResolution, Size availableAreaSize, int targetDpi)
+        {
+            var scalingFactor = targetDpi / (float)DocumentSettings.DefaultRasterDpi;
+            
+            var targetResolution = new ImageSize(
+                (int)(availableAreaSize.Width * scalingFactor), 
+                (int)(availableAreaSize.Height * scalingFactor));
+            
+            var isImageResolutionSmallerThanTarget = imageResolution.Width < targetResolution.Width || imageResolution.Height < targetResolution.Height;
+
+            if (isImageResolutionSmallerThanTarget)
+                return imageResolution;
+
+            return targetResolution;
         }
     }
 }

Source/QuestPDF/Elements/Table/Table.cs

@@ -112,7 +112,7 @@ namespace QuestPDF.Elements.Table
             UpdateColumnsWidth(availableSpace.Width);
             var renderingCommands = PlanLayout(availableSpace);
 
-            foreach (var command in renderingCommands)
+            foreach (var command in renderingCommands.OrderBy(x => x.Cell.ZIndex))
             {
                 if (command.Measurement.Type == SpacePlanType.FullRender)
                     command.Cell.IsRendered = true;

Source/QuestPDF/Elements/Table/TableCell.cs

@@ -8,6 +8,8 @@ namespace QuestPDF.Elements.Table
         public int Column { get; set; } = 0;
         public int ColumnSpan { get; set; } = 1;
         
+        public int ZIndex { get; set; }
+        
         public bool IsRendered { get; set; }
     }
 }

Source/QuestPDF/Elements/Table/TableLayoutPlanner.cs

@@ -16,9 +16,13 @@ namespace QuestPDF.Elements.Table
         {
             var cellsWindow = new List<TableCell>();
             (int x, int y) currentLocation = (1, 1);
+            var zIndex = 0;
             
             foreach (var cell in cells)
             {
+                cell.ZIndex = zIndex;
+                zIndex++;
+                
                 if (cellsWindow.Count > Math.Max(columnsCount, 16))
                 {
                     cellsWindow = cellsWindow

Source/QuestPDF/Fluent/GenerateExtensions.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using QuestPDF.Drawing;
 using QuestPDF.Infrastructure;
@@ -28,6 +29,17 @@ namespace QuestPDF.Fluent
             DocumentGenerator.GeneratePdf(stream, document);
         }
         
+        private static int GenerateAndShowCounter = 0;
+        
+        public static void GeneratePdfAndShow(this IDocument document)
+        {
+            GenerateAndShowCounter++;
+            
+            var filePath = Path.Combine(Path.GetTempPath(), $"QuestPDF Document {GenerateAndShowCounter}.pdf");
+            document.GeneratePdf(filePath);
+            OpenFileUsingDefaultProgram(filePath);
+        }
+
         #endregion
 
         #region XPS
@@ -50,32 +62,68 @@ namespace QuestPDF.Fluent
             DocumentGenerator.GenerateXps(stream, document);
         }
         
+        public static void GenerateXpsAndShow(this IDocument document)
+        {
+            var filePath = Path.Combine(Path.GetTempPath(), $"QuestPDF Document.xps");
+            document.GenerateXps(filePath);
+            OpenFileUsingDefaultProgram(filePath);
+        }
+        
         #endregion
 
         #region Images
 
         public static IEnumerable<byte[]> GenerateImages(this IDocument document)
         {
-            return DocumentGenerator.GenerateImages(document);
+            return document.GenerateImages(ImageGenerationSettings.Default);
         }
-        
+
+
+        public static IEnumerable<byte[]> GenerateImages(this IDocument document, ImageGenerationSettings settings)
+        {
+            return DocumentGenerator.GenerateImages(document, settings);
+        }
+
         /// <param name="filePath">Method should return fileName for given index</param>
         public static void GenerateImages(this IDocument document, Func<int, string> filePath)
+        {
+            document.GenerateImages(filePath, ImageGenerationSettings.Default);
+        }
+
+        /// <param name="filePath">Method should return fileName for given index</param>
+        public static void GenerateImages(this IDocument document, Func<int, string> filePath, ImageGenerationSettings settings)
         {
             var index = 0;
-            
-            foreach (var imageData in document.GenerateImages())
+
+            foreach (var imageData in document.GenerateImages(settings))
             {
                 var path = filePath(index);
-                
+
                 if (File.Exists(path))
                     File.Delete(path);
-                
+
                 File.WriteAllBytes(path, imageData);
                 index++;
             }
         }
 
         #endregion
+
+        #region Helpers
+
+        private static void OpenFileUsingDefaultProgram(string filePath)
+        {
+            var process = new Process
+            {
+                StartInfo = new ProcessStartInfo(filePath)
+                {
+                    UseShellExecute = true
+                }
+            };
+
+            process.Start();
+        }
+        
+        #endregion
     }
 }

Source/QuestPDF/Fluent/ImageExtensions.cs

@@ -7,62 +7,192 @@ using SkiaSharp;
 
 namespace QuestPDF.Fluent
 {
+    public class ImageDescriptor
+    {
+        private Elements.Image ImageElement { get; }
+        private AspectRatio AspectRatioElement { get; }
+        private float ImageAspectRatio { get; }
+
+        internal ImageDescriptor(Elements.Image imageElement, Elements.AspectRatio aspectRatioElement)
+        {
+            ImageElement = imageElement;
+            AspectRatioElement = aspectRatioElement;
+
+            var imageSize = ImageElement.DocumentImage.Size;
+            ImageAspectRatio = imageSize.Width / (float)imageSize.Height;
+        }
+        
+        /// <summary>
+        /// When enabled, the library will not attempt to resize the image to fit the target DPI, nor save it with target image quality.
+        /// </summary>
+        public ImageDescriptor UseOriginalImage(bool value = true)
+        {
+            ImageElement.UseOriginalImage = value;
+            return this;
+        }
+        
+        /// <summary>
+        /// The DPI (pixels-per-inch) at which images and features without native PDF support will be rasterized.
+        /// A larger DPI would create a PDF that reflects the original intent with better fidelity, but it can make for larger PDF files too, which would use more memory while rendering, and it would be slower to be processed or sent online or to printer.
+        /// When generating images, this parameter also controls the resolution of the generated content.
+        /// Default value is 144.
+        /// </summary>
+        public ImageDescriptor WithRasterDpi(int dpi)
+        {
+            ImageElement.TargetDpi = dpi;
+            return this;
+        }
+
+        /// <summary>
+        /// Encoding quality controls the trade-off between size and quality.
+        /// When the image is opaque, it will be encoded using the JPEG format with the selected quality setting.
+        /// When the image contains an alpha channel, it is always encoded using the PNG format and this option is ignored.
+        /// The default value is "very high quality".
+        /// </summary>
+        public ImageDescriptor WithCompressionQuality(ImageCompressionQuality quality)
+        {
+            ImageElement.CompressionQuality = quality;
+            return this;
+        }
+
+        #region Aspect Ratio
+        
+        /// <summary>
+        /// The image scales to take the entire available width. Default.
+        /// </summary>
+        public ImageDescriptor FitWidth()
+        {
+            return SetAspectRatio(AspectRatioOption.FitWidth);
+        }
+        
+        /// <summary>
+        /// The images scales to take the entire available height. Good in conjunction with constraining elements.
+        /// </summary>
+        public ImageDescriptor FitHeight()
+        {
+            return SetAspectRatio(AspectRatioOption.FitHeight);
+        }
+        
+        /// <summary>
+        /// This is the combination of both of the FitWidth and the FitHeight options. 
+        /// The element scales to occupy the entire available area while preserving its aspect ratio.
+        /// This means that sometimes it occupies the entire width and sometimes the entire height.
+        /// This is the safest option.
+        /// </summary>
+        public ImageDescriptor FitArea()
+        {
+            return SetAspectRatio(AspectRatioOption.FitArea);
+        }
+        
+        /// <summary>
+        /// The image resizes itself to occupy the entire available space.
+        /// It does not preserve proportions.
+        /// The image may look incorrectly scaled, and is not desired in most of the cases.
+        /// </summary>
+        public ImageDescriptor FitUnproportionally()
+        {
+            AspectRatioElement.Ratio = 0;
+            return this;
+        }
+        
+        private ImageDescriptor SetAspectRatio(AspectRatioOption option)
+        {
+            AspectRatioElement.Ratio = ImageAspectRatio;
+            AspectRatioElement.Option = option;
+            return this;
+        }
+        
+        #endregion
+    }
+    
     public static class ImageExtensions
     {
-        public static void Image(this IContainer parent, byte[] imageData, ImageScaling scaling = ImageScaling.FitWidth)
+        public static ImageDescriptor Image(this IContainer parent, byte[] imageData)
         {
-            var image = SKImage.FromEncodedData(imageData);
-            parent.Image(image, scaling);
+            var image = Infrastructure.Image.FromBinaryData(imageData);
+            return parent.Image(image);
         }
         
-        public static void Image(this IContainer parent, string filePath, ImageScaling scaling = ImageScaling.FitWidth)
+        public static ImageDescriptor Image(this IContainer parent, string filePath)
         {
-            var image = SKImage.FromEncodedData(filePath);
-            parent.Image(image, scaling);
+            var image = Infrastructure.Image.FromFile(filePath);
+            return parent.Image(image);
         }
         
-        public static void Image(this IContainer parent, Stream fileStream, ImageScaling scaling = ImageScaling.FitWidth)
+        public static ImageDescriptor Image(this IContainer parent, Stream fileStream)
         {
-            var image = SKImage.FromEncodedData(fileStream);
-            parent.Image(image, scaling);
+            var image = Infrastructure.Image.FromStream(fileStream);
+            return parent.Image(image);
         }
         
-        private static void Image(this IContainer parent, SKImage image, ImageScaling scaling = ImageScaling.FitWidth)
+        internal static ImageDescriptor Image(this IContainer parent, Infrastructure.Image image)
         {
             if (image == null)
                 throw new DocumentComposeException("Cannot load or decode provided image.");
             
-            var imageElement = new Image
+            var imageElement = new QuestPDF.Elements.Image
             {
-                InternalImage = image
+                DocumentImage = image
             };
 
-            if (scaling != ImageScaling.Resize)
+            var aspectRationElement = new AspectRatio
             {
-                var aspectRatio = image.Width / (float)image.Height;
-                parent = parent.AspectRatio(aspectRatio, Map(scaling));
-            }
-
-            parent.Element(imageElement);
-
-            static AspectRatioOption Map(ImageScaling scaling)
-            {
-                return scaling switch
-                {
-                    ImageScaling.FitWidth => AspectRatioOption.FitWidth,
-                    ImageScaling.FitHeight => AspectRatioOption.FitHeight,
-                    ImageScaling.FitArea => AspectRatioOption.FitArea,
-                    _ => throw new ArgumentOutOfRangeException()
-                };
-            }
+                Child = imageElement
+            };
+            
+            parent.Element(aspectRationElement);
+            return new ImageDescriptor(imageElement, aspectRationElement).FitWidth();
         }
 
-        public static void Image(this IContainer element, Func<Size, byte[]> imageSource)
+        public static void Image(this IContainer element, GenerateDynamicImageDelegate dynamicImageSource)
         {
             element.Element(new DynamicImage
             {
-                Source = imageSource
+                Source = dynamicImageSource
             });
         }
+        
+        #region Obsolete
+        
+        [Obsolete("This element has been changed since version 2023.5. Please use the Image method overload that takes the GenerateDynamicImageDelegate as an argument.")]
+        public static void Image(this IContainer element, Func<Size, byte[]> imageSource)
+        {
+            element.Image((ImageSize x) => imageSource(new Size(x.Width, x.Height)));
+        }
+        
+        [Obsolete("This element has been changed since version 2023.5. Please use the Image method overload that returns the ImageDescriptor object.")]
+        public static void Image(this IContainer parent, byte[] imageData, ImageScaling scaling)
+        {
+            parent.Image(imageData).ApplyScaling(scaling);
+        }
+        
+        [Obsolete("This element has been changed since version 2023.5. Please use the Image method overload that returns the ImageDescriptor object.")]
+        public static void Image(this IContainer parent, string filePath, ImageScaling scaling)
+        {
+            parent.Image(filePath).ApplyScaling(scaling);
+        }
+        
+        [Obsolete("This element has been changed since version 2023.5. Please use the Image method overload that returns the ImageDescriptor object.")]
+        public static void Image(this IContainer parent, Stream fileStream, ImageScaling scaling)
+        {
+            parent.Image(fileStream).ApplyScaling(scaling);
+        }
+        
+        internal static void ApplyScaling(this ImageDescriptor descriptor, ImageScaling scaling)
+        {
+            if (scaling == ImageScaling.Resize)
+                descriptor.FitUnproportionally();
+
+            else if (scaling == ImageScaling.FitWidth)
+                descriptor.FitWidth();
+            
+            else if (scaling == ImageScaling.FitHeight)
+                descriptor.FitHeight();
+            
+            else if (scaling == ImageScaling.FitArea)
+                descriptor.FitArea();
+        }
+        
+        #endregion
     }
 }

Source/QuestPDF/Fluent/MinimalApi.cs

@@ -8,6 +8,7 @@ namespace QuestPDF.Fluent
     {
         private Action<IDocumentContainer> ContentSource { get; }
         private DocumentMetadata Metadata { get; set; } = DocumentMetadata.Default;
+        private DocumentSettings Settings { get; set; } = DocumentSettings.Default;
 
         private Document(Action<IDocumentContainer> contentSource)
         {
@@ -25,9 +26,16 @@ namespace QuestPDF.Fluent
             return this;
         }
         
+        public Document WithSettings(DocumentSettings settings)
+        {
+            Settings = settings ?? Settings;
+            return this;
+        }
+        
         #region IDocument
 
         public DocumentMetadata GetMetadata() => Metadata;
+        public DocumentSettings GetSettings() => Settings;
         public void Compose(IDocumentContainer container) => ContentSource(container);
 
         #endregion

Source/QuestPDF/Helpers/Helpers.cs

@@ -6,6 +6,7 @@ using System.Reflection;
 using System.Text.RegularExpressions;
 using QuestPDF.Drawing;
 using QuestPDF.Infrastructure;
+using SkiaSharp;
 
 namespace QuestPDF.Helpers
 {
@@ -60,5 +61,63 @@ namespace QuestPDF.Helpers
         {
             return size.Width < 0f || size.Height < 0f;
         }
+        
+        internal static SKEncodedImageFormat ToSkImageFormat(this ImageFormat format)
+        {
+            return format switch
+            {
+                ImageFormat.Jpeg => SKEncodedImageFormat.Jpeg,
+                ImageFormat.Png => SKEncodedImageFormat.Png,
+                ImageFormat.Webp=> SKEncodedImageFormat.Webp,
+                _ => throw new ArgumentOutOfRangeException(nameof(format), format, null)
+            };
+        }
+        
+        internal static int ToQualityValue(this ImageCompressionQuality quality)
+        {
+            return quality switch
+            {
+                ImageCompressionQuality.Best => 100,
+                ImageCompressionQuality.VeryHigh => 90,
+                ImageCompressionQuality.High => 75,
+                ImageCompressionQuality.Medium => 50,
+                ImageCompressionQuality.Low => 25,
+                ImageCompressionQuality.VeryLow => 10,
+                _ => throw new ArgumentOutOfRangeException(nameof(quality), quality, null)
+            };
+        }
+        
+        internal static SKImage CompressImage(this SKImage image, ImageCompressionQuality compressionQuality)
+        {
+            var targetFormat = image.Info.IsOpaque 
+                ? SKEncodedImageFormat.Jpeg 
+                : SKEncodedImageFormat.Png;
+
+            if (targetFormat == SKEncodedImageFormat.Png)
+                compressionQuality = ImageCompressionQuality.Best;
+            
+            var data = image.Encode(targetFormat, compressionQuality.ToQualityValue());
+            return SKImage.FromEncodedData(data);
+        }
+
+        internal static SKImage ResizeAndCompressImage(this SKImage image, ImageSize targetResolution, ImageCompressionQuality compressionQuality)
+        {
+            if (image.Width == targetResolution.Width && image.Height == targetResolution.Height)
+                return CompressImage(image, compressionQuality);
+            
+            var imageInfo = new SKImageInfo(targetResolution.Width, targetResolution.Height, image.Info.ColorType, image.Info.AlphaType, image.Info.ColorSpace);
+            
+            using var resultImage = SKImage.Create(imageInfo);
+            image.ScalePixels(resultImage.PeekPixels(), SKFilterQuality.Medium);
+            
+            return CompressImage(resultImage, compressionQuality);
+        }
+
+        internal static SKImage GetImageWithSmallerSize(SKImage one, SKImage second)
+        {
+            return one.EncodedData.Size < second.EncodedData.Size
+                ? one
+                : second;
+        }
     }
 }

Source/QuestPDF/Helpers/Placeholders.cs

@@ -213,10 +213,10 @@ namespace QuestPDF.Helpers
 
         public static byte[] Image(int width, int height)
         {
-            return Image(new Size(width, height));
+            return Image(new ImageSize(width, height));
         }
         
-        public static byte[] Image(Size size)
+        public static byte[] Image(ImageSize size)
         {
             // shuffle corner positions
             var targetPositions = new[]
@@ -239,7 +239,7 @@ namespace QuestPDF.Helpers
                 .ToArray();
             
             // create image with white background
-            var imageInfo = new SKImageInfo((int)size.Width, (int)size.Height);
+            var imageInfo = new SKImageInfo(size.Width, size.Height);
             using var surface = SKSurface.Create(imageInfo);
    
             using var backgroundPaint = new SKPaint

Source/QuestPDF/Infrastructure/ContentDirection.cs

@@ -1,6 +1,6 @@
 namespace QuestPDF.Infrastructure
 {
-    internal enum ContentDirection
+    public enum ContentDirection
     {
         LeftToRight,
         RightToLeft

Source/QuestPDF/Infrastructure/DocumentMetadata.cs

@@ -1,14 +1,9 @@
 using System;
-using QuestPDF.Infrastructure;
 
-namespace QuestPDF.Drawing
+namespace QuestPDF.Infrastructure
 {
     public class DocumentMetadata
     {
-        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; }
@@ -19,6 +14,10 @@ namespace QuestPDF.Drawing
         public DateTime CreationDate { get; set; } = DateTime.Now;
         public DateTime ModifiedDate { get; set; } = DateTime.Now;
 
+        public static DocumentMetadata Default => new DocumentMetadata();
+        
+        #region Deprecated properties
+        
         [Obsolete("This API has been moved since version 2022.9. Please use the QuestPDF.Settings.DocumentLayoutExceptionThreshold static property.")]
         public int DocumentLayoutExceptionThreshold
         {
@@ -39,7 +38,16 @@ namespace QuestPDF.Drawing
             get => Settings.EnableDebugging;
             set => Settings.EnableDebugging = value;
         }
-
-        public static DocumentMetadata Default => new DocumentMetadata();
+        
+        [Obsolete("This API has been moved since version 2023.5. Please use the QuestPDF.Infrastructure.DocumentSettings API.")]
+        public int? ImageQuality { get; set; }
+        
+        [Obsolete("This API has been moved since version 2023.5. Please use the QuestPDF.Infrastructure.DocumentSettings API.")]
+        public int? RasterDpi { get; set; }
+        
+        [Obsolete("This API has been moved since version 2023.5. Please use the QuestPDF.Infrastructure.DocumentSettings API.")]
+        public bool? PdfA { get; set; }
+        
+        #endregion
     }
 }

Source/QuestPDF/Infrastructure/DocumentSettings.cs

@@ -0,0 +1,34 @@
+namespace QuestPDF.Infrastructure
+{
+    public class DocumentSettings
+    {
+        public const int DefaultRasterDpi = 72;
+        
+        /// <summary>
+        /// Gets or sets a value indicating whether or not make the document PDF/A-2b conformant.
+        /// If true, include XMP metadata, a document UUID, and sRGB output intent information.
+        /// This adds length to the document and makes it non-reproducable, but are necessary features for PDF/A-2b conformance.
+        /// </summary>
+        public bool PdfA { get; set; } = false;
+
+        /// <summary>
+        /// Encoding quality controls the trade-off between size and quality.
+        /// When the image is opaque, it will be encoded using the JPEG format with the selected quality setting.
+        /// When the image contains an alpha channel, it is always encoded using the PNG format and this option is ignored.
+        /// The default value is "high quality".
+        /// </summary>
+        public ImageCompressionQuality ImageCompressionQuality { get; set; } = ImageCompressionQuality.VeryHigh;
+
+        /// <summary>
+        /// The DPI (pixels-per-inch) at which images and features without native PDF support will be rasterized.
+        /// A larger DPI would create a PDF that reflects the original intent with better fidelity, but it can make for larger PDF files too, which would use more memory while rendering, and it would be slower to be processed or sent online or to printer.
+        /// When generating images, this parameter also controls the resolution of the generated content.
+        /// Default value is 144.
+        /// </summary>
+        public int ImageRasterDpi { get; set; } = DefaultRasterDpi * 2;
+ 
+        public ContentDirection ContentDirection { get; set; } = ContentDirection.LeftToRight;
+        
+        public static DocumentSettings Default => new DocumentSettings();
+    }
+}

Source/QuestPDF/Infrastructure/IDocument.cs

@@ -4,7 +4,14 @@ namespace QuestPDF.Infrastructure
 {
     public interface IDocument
     {
+#if NETCOREAPP3_0_OR_GREATER
+        public DocumentMetadata GetMetadata() => DocumentMetadata.Default; 
+        public DocumentSettings GetSettings() => DocumentSettings.Default;
+#else
         DocumentMetadata GetMetadata();
+        DocumentSettings GetSettings();
+#endif
+        
         void Compose(IDocumentContainer container);
     }
 }

Source/QuestPDF/Infrastructure/Image.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using QuestPDF.Drawing.Exceptions;
+using QuestPDF.Helpers;
+using SkiaSharp;
+
+namespace QuestPDF.Infrastructure
+{
+    internal record GetImageVersionRequest
+    {
+        internal ImageSize Resolution { get; set; }
+        internal ImageCompressionQuality CompressionQuality { get; set; }
+    }
+    
+    public class Image
+    {
+        internal SKImage SkImage { get; }
+        internal ImageSize Size { get; }
+        internal bool IsDocumentScoped { get; }
+        
+        internal LinkedList<(GetImageVersionRequest request, SKImage image)> ScaledImageCache { get; } = new();
+
+        internal Image(SKImage image, bool isDocumentScoped)
+        {
+            SkImage = image;
+            IsDocumentScoped = isDocumentScoped;
+            Size = new ImageSize(image.Width, image.Height);
+        }
+        
+        internal void Dispose()
+        {
+            SkImage.Dispose();
+
+            foreach (var cacheKey in ScaledImageCache)
+                cacheKey.image.Dispose();
+        } 
+
+        #region Scaling Image
+
+        internal SKImage GetVersionOfSize(GetImageVersionRequest request)
+        {
+            foreach (var cacheKey in ScaledImageCache)
+            {
+                if (cacheKey.request == request)
+                    return cacheKey.image;
+            }
+
+            var result = SkImage.ResizeAndCompressImage(request.Resolution, request.CompressionQuality);
+            ScaledImageCache.AddLast((request, result));
+            return result;
+        }
+
+        #endregion
+
+        #region public constructors
+
+        internal static Image FromSkImage(SKImage image)
+        {
+            return CreateImage(image);
+        }
+
+        public static Image FromBinaryData(byte[] imageData)
+        {
+            return CreateImage(SKImage.FromEncodedData(imageData));
+        }
+
+        public static Image FromFile(string filePath)
+        {
+            return CreateImage(SKImage.FromEncodedData(filePath));
+        }
+
+        public static Image FromStream(Stream fileStream)
+        {
+            return CreateImage(SKImage.FromEncodedData(fileStream));
+        }
+
+        private static Image CreateImage(SKImage? image)
+        {
+            if (image == null)
+                throw new DocumentComposeException("Cannot load or decode provided image.");
+
+            return new Image(image, true);
+        }
+
+        #endregion
+    }
+
+    public class SharedImage : Image, IDisposable
+    {
+        internal SharedImage(SKImage image) : base(image, false)
+        {
+            
+        }
+        
+        public void Dispose()
+        {
+            base.Dispose();
+        } 
+        
+        #region public constructors
+        
+        public static new SharedImage FromBinaryData(byte[] imageData)
+        {
+            return CreateImage(SKImage.FromEncodedData(imageData));
+        }
+
+        public static new SharedImage FromFile(string filePath)
+        {
+            return CreateImage(SKImage.FromEncodedData(filePath));
+        }
+
+        public static new SharedImage FromStream(Stream fileStream)
+        {
+            return CreateImage(SKImage.FromEncodedData(fileStream));
+        }
+
+        private static SharedImage CreateImage(SKImage? image)
+        {
+            if (image == null)
+                throw new DocumentComposeException("Cannot load or decode provided image.");
+
+            var result = new SharedImage(image);
+            
+            return result;
+        }
+
+        #endregion
+    }
+}

Source/QuestPDF/Infrastructure/ImageCompressionQuality.cs

@@ -0,0 +1,35 @@
+namespace QuestPDF.Infrastructure
+{
+    public enum ImageCompressionQuality
+    {
+        /// <summary>
+        /// JPEG format with compression set to 100 out of 100
+        /// </summary>
+        Best,
+
+        /// <summary>
+        /// JPEG format with compression set to 90 out of 100
+        /// </summary>
+        VeryHigh,
+
+        /// <summary>
+        /// JPEG format with compression set to 75 out of 100
+        /// </summary>
+        High,
+
+        /// <summary>
+        /// JPEG format with compression set to 50 out of 100
+        /// </summary>
+        Medium,
+
+        /// <summary>
+        /// JPEG format with compression set to 25 out of 100
+        /// </summary>
+        Low,
+
+        /// <summary>
+        /// JPEG format with compression set to 10 out of 100
+        /// </summary>
+        VeryLow
+    }
+}

Source/QuestPDF/Infrastructure/ImageFormat.cs

@@ -0,0 +1,9 @@
+namespace QuestPDF.Infrastructure
+{
+    public enum ImageFormat
+    {
+        Jpeg,
+        Png,
+        Webp
+    }
+}

Source/QuestPDF/Infrastructure/ImageGenerationSettings.cs

@@ -0,0 +1,27 @@
+using SkiaSharp;
+
+namespace QuestPDF.Infrastructure
+{
+    public class ImageGenerationSettings
+    {
+        /// <summary>
+        /// The file format used to encode the image(s).
+        /// </summary>
+        public ImageFormat ImageFormat { get; set; } = ImageFormat.Png;
+
+        /// <summary>
+        /// Encoding quality controls the trade-off between size and quality.
+        /// The default value is "high quality".
+        /// </summary>
+        public ImageCompressionQuality ImageCompressionQuality { get; set; } = ImageCompressionQuality.VeryHigh;
+
+        /// <summary>
+        /// The DPI (pixels-per-inch) at which the document will be rasterized. This parameter controls the resolution of produced images.
+        /// Default value is 144.
+        /// </summary>
+        public int RasterDpi { get; set; } = DocumentSettings.DefaultRasterDpi * 2;
+
+
+        public static ImageGenerationSettings Default => new ImageGenerationSettings();
+    }
+}

Source/QuestPDF/Infrastructure/ImageSize.cs

@@ -0,0 +1,14 @@
+namespace QuestPDF.Infrastructure
+{
+    public struct ImageSize
+    {
+        public readonly int Width;
+        public readonly int Height;
+
+        public ImageSize(int width, int height)
+        {
+            Width = width;
+            Height = height;
+        }
+    }
+}

Source/QuestPDF/Infrastructure/LicenseType.cs

@@ -0,0 +1,30 @@
+namespace QuestPDF.Infrastructure
+{
+    public enum LicenseType
+    {
+        /// <summary>
+        /// <para>We love and highly appreciate the .NET Community and therefore the vast majority of users are welcome to use the library under the QuestPDF Community MIT License, without any limitations, even for commercial usage. Please kindly check if you are eligible to use this license.</para>
+        /// <para>License comparison: http://www.questpdf.com/pricing.html#license</para>
+        /// <para>License link: https://www.questpdf.com/license-community.html</para>
+        /// </summary>
+        Community,
+        
+        /// <summary>
+        /// <para>You must purchase the QuestPDF Professional 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, <c>and there are up to 10 developers</c>.</para>
+        /// <para>If the number of developers is more than 10, you must purchase the QuestPDF Enterprise license.</para>
+        /// <para>Before making a license purchase, please evaluate the library in a non-production environment.</para>
+        /// <para>License comparison: http://www.questpdf.com/pricing.html#license</para>
+        /// <para>License link: https://www.questpdf.com/license-commercial.html</para>
+        /// </summary>
+        Professional,
+        
+        /// <summary>
+        /// <para>You must purchase the QuestPDF Professional 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.</para>
+        /// <para>If there are less than 10 developers, you are eligible to use the cheaper QuestPDF Professional License.</para>
+        /// <para>Before making a license purchase, please evaluate the library in a non-production environment.</para>
+        /// <para>License comparison: http://www.questpdf.com/pricing.html#license</para>
+        /// <para>License link: https://www.questpdf.com/license-commercial.html</para>
+        /// </summary>
+        Enterprise
+    }
+}

Source/QuestPDF/Infrastructure/TextStyleManager.cs

@@ -256,9 +256,11 @@ namespace QuestPDF.Infrastructure
         {
             var result = style;
             
+            if (string.IsNullOrWhiteSpace(result.FontFamily) || overrideFontFamily)
+                result = MutateStyle(result, TextStyleProperty.FontFamily, parent.FontFamily, overrideStyle);
+                
             result = MutateStyle(result, TextStyleProperty.Color, parent.Color, overrideStyle);
             result = MutateStyle(result, TextStyleProperty.BackgroundColor, parent.BackgroundColor, overrideStyle);
-            result = MutateStyle(result, TextStyleProperty.FontFamily, parent.FontFamily, overrideStyle);
             result = MutateStyle(result, TextStyleProperty.Size, parent.Size, overrideStyle);
             result = MutateStyle(result, TextStyleProperty.LineHeight, parent.LineHeight, overrideStyle);
             result = MutateStyle(result, TextStyleProperty.LetterSpacing, parent.LetterSpacing, overrideStyle);

Source/QuestPDF/Previewer/ExceptionDocument.cs

@@ -20,6 +20,11 @@ namespace QuestPDF.Previewer
         {
             return DocumentMetadata.Default;
         }
+        
+        public DocumentSettings GetSettings()
+        {
+            return DocumentSettings.Default;
+        }
 
         public void Compose(IDocumentContainer document)
         {

Source/QuestPDF/Previewer/PreviewerService.cs

@@ -18,8 +18,8 @@ namespace QuestPDF.Previewer
         
         public  event Action? OnPreviewerStopped;
 
-        private const int RequiredPreviewerVersionMajor = 2022;
-        private const int RequiredPreviewerVersionMinor = 12;
+        private const int RequiredPreviewerVersionMajor = 2023;
+        private const int RequiredPreviewerVersionMinor = 5;
         
         public PreviewerService(int port)
         {

Source/QuestPDF/QuestPDF.csproj

@@ -3,7 +3,7 @@
         <Authors>MarcinZiabek</Authors>
         <Company>CodeFlint</Company>
         <PackageId>QuestPDF</PackageId>
-        <Version>2022.12.3</Version>
+        <Version>2023.5.0</Version>
         <PackageDescription>QuestPDF is an open-source, modern and battle-tested library that can help you with generating PDF documents by offering friendly, discoverable and predictable C# fluent API. Easily generate PDF reports, invoices, exports, etc.</PackageDescription>
         <PackageReleaseNotes>$([System.IO.File]::ReadAllText("$(MSBuildProjectDirectory)/Resources/ReleaseNotes.txt"))</PackageReleaseNotes>
         <LangVersion>9</LangVersion>
@@ -12,15 +12,17 @@
         <PackageIconUrl>https://www.questpdf.com/images/package-logo.png</PackageIconUrl>
         <PackageProjectUrl>https://www.questpdf.com/</PackageProjectUrl>
         <PackageReadmeFile>PackageReadme.md</PackageReadmeFile>
+        <PackageLicenseFile>PackageLicense.md</PackageLicenseFile>
+        <PackageRequireLicenseAcceptance>True</PackageRequireLicenseAcceptance>
         <RepositoryUrl>https://github.com/QuestPDF/library.git</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
         <Copyright>Marcin Ziąbek, QuestPDF contributors</Copyright>
         <PackageTags>pdf report file export generate generation tool create creation render portable document format quest html library converter open source free standard core</PackageTags>
-        <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <Nullable>enable</Nullable>
         <TargetFrameworks>net462;netstandard2.0;netcoreapp2.0;netcoreapp3.0;net6.0</TargetFrameworks>
         <IncludeSymbols>true</IncludeSymbols>
         <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+        <GenerateDocumentationFile>True</GenerateDocumentationFile>
     </PropertyGroup>
 
     <ItemGroup>
@@ -37,32 +39,43 @@
     </ItemGroup>
 
     <ItemGroup>
-      <EmbeddedResource Include="Resources\ImagePlaceholder.png" />
-      <EmbeddedResource Include="Resources\Logo.png" />
-      <None Remove="ImagePlaceholder.png" />
+        <None Include="Resources\PackageReadme.md" Pack="true" PackagePath="\" />
+        <None Include="Resources\PackageLicense.md" Pack="true" PackagePath="\" />
+
+        <None Include="Resources\Logo.png" Pack="true" PackagePath="\" />
+        <EmbeddedResource Include="Resources\Logo.png" />
         
-      <None Include="Resources\Logo.png" Pack="true" PackagePath="\" />
-      <None Include="Resources\PackageReadme.md" Pack="true" PackagePath="\" />
+        <None Remove="ImagePlaceholder.png" />
+        <EmbeddedResource Include="Resources\ImagePlaceholder.png" />
         
-      <None Remove="Resources\DefaultFont\Lato-Black.ttf" />
-      <EmbeddedResource Include="Resources\DefaultFont\Lato-Black.ttf" />
-      <None Remove="Resources\DefaultFont\Lato-BlackItalic.ttf" />
-      <EmbeddedResource Include="Resources\DefaultFont\Lato-BlackItalic.ttf" />
-      <None Remove="Resources\DefaultFont\Lato-Bold.ttf" />
-      <EmbeddedResource Include="Resources\DefaultFont\Lato-Bold.ttf" />
-      <None Remove="Resources\DefaultFont\Lato-BoldItalic.ttf" />
-      <EmbeddedResource Include="Resources\DefaultFont\Lato-BoldItalic.ttf" />
-      <None Remove="Resources\DefaultFont\Lato-Italic.ttf" />
-      <EmbeddedResource Include="Resources\DefaultFont\Lato-Italic.ttf" />
-      <None Remove="Resources\DefaultFont\Lato-Light.ttf" />
-      <EmbeddedResource Include="Resources\DefaultFont\Lato-Light.ttf" />
-      <None Remove="Resources\DefaultFont\Lato-LightItalic.ttf" />
-      <EmbeddedResource Include="Resources\DefaultFont\Lato-LightItalic.ttf" />
-      <None Remove="Resources\DefaultFont\Lato-Regular.ttf" />
-      <EmbeddedResource Include="Resources\DefaultFont\Lato-Regular.ttf" />
-      <None Remove="Resources\DefaultFont\Lato-Thin.ttf" />
-      <EmbeddedResource Include="Resources\DefaultFont\Lato-Thin.ttf" />
-      <None Remove="Resources\DefaultFont\Lato-ThinItalic.ttf" />
-      <EmbeddedResource Include="Resources\DefaultFont\Lato-ThinItalic.ttf" />
+        <None Remove="Resources\DefaultFont\Lato-Black.ttf" />
+        <EmbeddedResource Include="Resources\DefaultFont\Lato-Black.ttf" />
+        
+        <None Remove="Resources\DefaultFont\Lato-BlackItalic.ttf" />
+        <EmbeddedResource Include="Resources\DefaultFont\Lato-BlackItalic.ttf" />
+        
+        <None Remove="Resources\DefaultFont\Lato-Bold.ttf" />
+        <EmbeddedResource Include="Resources\DefaultFont\Lato-Bold.ttf" />
+        
+        <None Remove="Resources\DefaultFont\Lato-BoldItalic.ttf" />
+        <EmbeddedResource Include="Resources\DefaultFont\Lato-BoldItalic.ttf" />
+        
+        <None Remove="Resources\DefaultFont\Lato-Italic.ttf" />
+        <EmbeddedResource Include="Resources\DefaultFont\Lato-Italic.ttf" />
+        
+        <None Remove="Resources\DefaultFont\Lato-Light.ttf" />
+        <EmbeddedResource Include="Resources\DefaultFont\Lato-Light.ttf" />
+        
+        <None Remove="Resources\DefaultFont\Lato-LightItalic.ttf" />
+        <EmbeddedResource Include="Resources\DefaultFont\Lato-LightItalic.ttf" />
+        
+        <None Remove="Resources\DefaultFont\Lato-Regular.ttf" />
+        <EmbeddedResource Include="Resources\DefaultFont\Lato-Regular.ttf" />
+        
+        <None Remove="Resources\DefaultFont\Lato-Thin.ttf" />
+        <EmbeddedResource Include="Resources\DefaultFont\Lato-Thin.ttf" />
+        
+        <None Remove="Resources\DefaultFont\Lato-ThinItalic.ttf" />
+        <EmbeddedResource Include="Resources\DefaultFont\Lato-ThinItalic.ttf" />
     </ItemGroup>
 </Project>

Source/QuestPDF/Resources/PackageLicense.md

@@ -0,0 +1,59 @@
+# QuestPDF License
+
+## What license do you need?
+
+Suppose 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. In that case, you must purchase the QuestPDF Professional or Enterprise License, depending on the number of software developers.
+
+We love and highly appreciate the .NET Community. Therefore, most users are welcome to use the library entirely 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.
+
+If you still want to support library development, please consider purchasing the Professional License.
+
+Please find all details regarding the QuestPDF license on the [official webpage](https://www.questpdf.com/pricing.html).
+
+Being a healthy and growing community is the primary goal that motivates us to pursue professionalism. Thank you!
+
+
+## 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.
+
+
+
+## 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 right to distribute the Software (without royalty) as part of packaged commercial products.
+
+### 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.

Source/QuestPDF/Resources/ReleaseNotes.txt

@@ -1,22 +1,8 @@
-Feature: implemented LetterSpacing property for the Text element
-Improvement: the Text element API accepts now only string values, objects are not automatically converted anymore
-Fix: the Alignment element incorrectly limits size of its child when only one axis is set (horizontal or vertical)
-Maintenance: Updated SkiaSharp dependency to 2.88.3
-
-In version 2022.12.1:
-Fixed: loading fonts from embedded resource via the FontManager.RegisterFontFromEmbeddedResource method
-Fixed: better layout calculation stability for the Column element
-Improvement: exposed missing API method for the Dynamic component, enabling applying more advanced optimizations
-Improvement: better API documentation for the Settings.DocumentLayoutExceptionThreshold property
-
-In version 2022.12.2:
-Performance improvements in various areas
-Text rendering stability improvements
-Fixed: the Settings.CheckIfAllTextGlyphsAreAvailable setting does not work correctly
-
-In version 2022.12.3:
-Fix: inconsistent text height when using multiple lines with different TextStyles
-Improvement: added validation for color arguments
-Fix: the inlined element is shown only once in the header but should be repeated on each page
-
-This release was possible thanks to enormous help of AntonyCorbett, thank you!
+Version 2023.5.0
+- Simplified development loop by introducing cross-platform methods: GeneratePdfAndShow() and GenerateXpsAndShow()
+- New shared image API: the ability to define a single image resource that is used in multiple places in the document without increasing its size
+- New DocumentSettings API: target image raster DPI - now, the library automatically resizes all images to achieve desired DPI (dots-per-inch) resolution. It allows for minimizing output file size
+- New DocumentSettings API: target image compression quality - the ability to specify the balance between size and quality for images in the document. It allows for minimizing output file size
+- Refactoring: moved the PdfA setting from the DocumentMetadata class to the DocumentSettings class
+- Improved Image API by providing additional FluentA API methods
+- Improvement: the GenerateImage element now provides the expected image resolution, abstracting away the physical area size and target image DPI

Source/QuestPDF/Settings.cs

@@ -1,7 +1,15 @@
-namespace QuestPDF
+using QuestPDF.Infrastructure;
+
+namespace QuestPDF
 {
     public static class Settings
     {
+        /// <summary>
+        /// <para>Please kindly select license type that applies to your usage of the QuestPDF library.</para>
+        /// <para>For more details, please check the QuestPDF License and Pricing page: https://www.questpdf.com/pricing.html</para>
+        /// </summary>
+        public static LicenseType? License { get; set; }
+        
         /// <summary>
         /// This value represents the maximum number of pages that the library produces.
         /// This is useful when layout constraints are too strong, e.g. one element does not fit in another.