From c2f3f3fdf2aec3d0cd986fc8b786d3470995e0ee Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 5 Dec 2019 15:31:54 +0100
Subject: [PATCH 01/46] Added failing tests for #3323.

---
 .../Xaml/ResourceDictionaryTests.cs           | 123 ++++++++++++++++++
 1 file changed, 123 insertions(+)
 create mode 100644 tests/Avalonia.Markup.Xaml.UnitTests/Xaml/ResourceDictionaryTests.cs

diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/ResourceDictionaryTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/ResourceDictionaryTests.cs
new file mode 100644
index 0000000000..d0cdef3c0b
--- /dev/null
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/ResourceDictionaryTests.cs
@@ -0,0 +1,123 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using Avalonia.Controls;
+using Avalonia.Controls.Presenters;
+using Avalonia.Controls.Templates;
+using Avalonia.Media;
+using Avalonia.Styling;
+using Avalonia.UnitTests;
+using Xunit;
+
+namespace Avalonia.Markup.Xaml.UnitTests.Xaml
+{
+    public class ResourceDictionaryTests : XamlTestBase
+    {
+        [Fact]
+        public void StaticResource_Works_In_ResourceDictionary()
+        {
+            using (StyledWindow())
+            {
+                var xaml = @"
+<ResourceDictionary xmlns='https://github.com/avaloniaui'
+                    xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
+  <Color x:Key='Red'>Red</Color>
+  <SolidColorBrush x:Key='RedBrush' Color='{StaticResource Red}'/>
+</ResourceDictionary>";
+                var loader = new AvaloniaXamlLoader();
+                var resources = (ResourceDictionary)loader.Load(xaml);
+                var brush = (SolidColorBrush)resources["RedBrush"];
+
+                Assert.Equal(Colors.Red, brush.Color);
+            }
+        }
+
+        [Fact]
+        public void DynamicResource_Works_In_ResourceDictionary()
+        {
+            using (StyledWindow())
+            {
+                var xaml = @"
+<ResourceDictionary xmlns='https://github.com/avaloniaui'
+                    xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
+  <Color x:Key='Red'>Red</Color>
+  <SolidColorBrush x:Key='RedBrush' Color='{DynamicResource Red}'/>
+</ResourceDictionary>";
+                var loader = new AvaloniaXamlLoader();
+                var resources = (ResourceDictionary)loader.Load(xaml);
+                var brush = (SolidColorBrush)resources["RedBrush"];
+
+                Assert.Equal(Colors.Red, brush.Color);
+            }
+        }
+
+        [Fact]
+        public void DynamicResource_Finds_Resource_In_Parent_Dictionary()
+        {
+            var dictionaryXaml = @"
+<ResourceDictionary xmlns='https://github.com/avaloniaui'
+                    xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
+  <SolidColorBrush x:Key='RedBrush' Color='{DynamicResource Red}'/>
+</ResourceDictionary>";
+
+            using (StyledWindow(assets: ("test:dict.xaml", dictionaryXaml)))
+            {
+                var xaml = @"
+<Window xmlns='https://github.com/avaloniaui'
+        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
+    <Window.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <ResourceInclude Source='test:dict.xaml'/>
+            </ResourceDictionary.MergedDictionaries>
+        </ResourceDictionary>
+        <Color x:Key='Red'>Red</Color>
+    </Window.Resources>
+    <Button Name='button' Background='{DynamicResource RedBrush}'/>
+</Window>";
+
+                var loader = new AvaloniaXamlLoader();
+                var window = (Window)loader.Load(xaml);
+                var button = window.FindControl<Button>("button");
+
+                var brush = Assert.IsType<SolidColorBrush>(button.Background);
+                Assert.Equal(Colors.Red, brush.Color);
+
+                window.Resources["Red"] = Colors.Green;
+
+                Assert.Equal(Colors.Green, brush.Color);
+            }
+        }
+
+        private IDisposable StyledWindow(params (string, string)[] assets)
+        {
+            var services = TestServices.StyledWindow.With(
+                assetLoader: new MockAssetLoader(assets),
+                theme: () => new Styles
+                {
+                    WindowStyle(),
+                });
+
+            return UnitTestApplication.Start(services);
+        }
+
+        private Style WindowStyle()
+        {
+            return new Style(x => x.OfType<Window>())
+            {
+                Setters =
+                {
+                    new Setter(
+                        Window.TemplateProperty,
+                        new FuncControlTemplate<Window>((x, scope) =>
+                            new ContentPresenter
+                            {
+                                Name = "PART_ContentPresenter",
+                                [!ContentPresenter.ContentProperty] = x[!Window.ContentProperty],
+                            }.RegisterInNameScope(scope)))
+                }
+            };
+        }
+    }
+}

From 601abac056c1d17b8e5abb72c3dd4bf233728f23 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 5 Dec 2019 15:35:27 +0100
Subject: [PATCH 02/46] Set resource parent for merged dictionaries.

Allows `DynamicResource` and `StaticResource` in merged resource dictionaries to work properly.

Fixes #3323
---
 .../ISetResourceParent.cs}                    | 14 ++---
 .../Controls/ResourceDictionary.cs            | 62 ++++++++++++++++++-
 src/Avalonia.Styling/StyledElement.cs         |  4 +-
 src/Avalonia.Styling/Styling/Style.cs         | 12 ++--
 src/Avalonia.Styling/Styling/Styles.cs        | 20 +++---
 .../MarkupExtensions/ResourceInclude.cs       | 26 +++++++-
 .../Styling/StyleInclude.cs                   | 10 +--
 .../ResourceDictionaryTests.cs                | 45 +++++++++-----
 8 files changed, 144 insertions(+), 49 deletions(-)
 rename src/Avalonia.Styling/{Styling/ISetStyleParent.cs => Controls/ISetResourceParent.cs} (61%)

diff --git a/src/Avalonia.Styling/Styling/ISetStyleParent.cs b/src/Avalonia.Styling/Controls/ISetResourceParent.cs
similarity index 61%
rename from src/Avalonia.Styling/Styling/ISetStyleParent.cs
rename to src/Avalonia.Styling/Controls/ISetResourceParent.cs
index bca3d9d714..a1264adc34 100644
--- a/src/Avalonia.Styling/Styling/ISetStyleParent.cs
+++ b/src/Avalonia.Styling/Controls/ISetResourceParent.cs
@@ -1,29 +1,27 @@
-using Avalonia.Controls;
-
-namespace Avalonia.Styling
+namespace Avalonia.Controls
 {
     /// <summary>
-    /// Defines an interface through which a <see cref="Style"/>'s parent can be set.
+    /// Defines an interface through which an <see cref="IResourceNode"/>'s parent can be set.
     /// </summary>
     /// <remarks>
     /// You should not usually need to use this interface - it is for internal use only.
     /// </remarks>
-    public interface ISetStyleParent : IStyle
+    public interface ISetResourceParent : IResourceNode
     {
         /// <summary>
-        /// Sets the style parent.
+        /// Sets the resource parent.
         /// </summary>
         /// <param name="parent">The parent.</param>
         void SetParent(IResourceNode parent);
 
         /// <summary>
-        /// Notifies the style that a change has been made to resources that apply to it.
+        /// Notifies the resource node that a change has been made to the resources in its parent.
         /// </summary>
         /// <param name="e">The event args.</param>
         /// <remarks>
         /// This method will be called automatically by the framework, you should not need to call
         /// this method yourself.
         /// </remarks>
-        void NotifyResourcesChanged(ResourcesChangedEventArgs e);
+        void ParentResourcesChanged(ResourcesChangedEventArgs e);
     }
 }
diff --git a/src/Avalonia.Styling/Controls/ResourceDictionary.cs b/src/Avalonia.Styling/Controls/ResourceDictionary.cs
index 901e27b7b7..acc2db1ff7 100644
--- a/src/Avalonia.Styling/Controls/ResourceDictionary.cs
+++ b/src/Avalonia.Styling/Controls/ResourceDictionary.cs
@@ -12,8 +12,12 @@ namespace Avalonia.Controls
     /// <summary>
     /// An indexed dictionary of resources.
     /// </summary>
-    public class ResourceDictionary : AvaloniaDictionary<object, object>, IResourceDictionary
+    public class ResourceDictionary : AvaloniaDictionary<object, object>,
+        IResourceDictionary,
+        IResourceNode,
+        ISetResourceParent
     {
+        private IResourceNode _parent;
         private AvaloniaList<IResourceProvider> _mergedDictionaries;
 
         /// <summary>
@@ -39,6 +43,12 @@ namespace Avalonia.Controls
                     _mergedDictionaries.ForEachItem(
                         x =>
                         {
+                            if (x is ISetResourceParent setParent)
+                            {
+                                setParent.SetParent(this);
+                                setParent.ParentResourcesChanged(new ResourcesChangedEventArgs());
+                            }
+
                             if (x.HasResources)
                             {
                                 OnResourcesChanged();
@@ -48,11 +58,18 @@ namespace Avalonia.Controls
                         },
                         x =>
                         {
+                            if (x is ISetResourceParent setParent)
+                            {
+                                setParent.SetParent(null);
+                                setParent.ParentResourcesChanged(new ResourcesChangedEventArgs());
+                            }
+
                             if (x.HasResources)
                             {
                                 OnResourcesChanged();
                             }
 
+                            (x as ISetResourceParent)?.SetParent(null);
                             x.ResourcesChanged -= MergedDictionaryResourcesChanged;
                         },
                         () => { });
@@ -68,6 +85,27 @@ namespace Avalonia.Controls
             get => Count > 0 || (_mergedDictionaries?.Any(x => x.HasResources) ?? false);
         }
 
+        /// <inheritdoc/>
+        IResourceNode IResourceNode.ResourceParent => _parent;
+
+        /// <inheritdoc/>
+        void ISetResourceParent.ParentResourcesChanged(ResourcesChangedEventArgs e)
+        {
+            NotifyMergedDictionariesResourcesChanged(e);
+            ResourcesChanged?.Invoke(this, e);
+        }
+
+        /// <inheritdoc/>
+        void ISetResourceParent.SetParent(IResourceNode parent)
+        {
+            if (_parent != null && parent != null)
+            {
+                throw new InvalidOperationException("The ResourceDictionary already has a parent.");
+            }
+            
+            _parent = parent;
+        }
+
         /// <inheritdoc/>
         public bool TryGetResource(object key, out object value)
         {
@@ -95,7 +133,27 @@ namespace Avalonia.Controls
             ResourcesChanged?.Invoke(this, new ResourcesChangedEventArgs());
         }
 
-        private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e) => OnResourcesChanged();
+        private void NotifyMergedDictionariesResourcesChanged(ResourcesChangedEventArgs e)
+        {
+            if (_mergedDictionaries != null)
+            {
+                for (var i = _mergedDictionaries.Count - 1; i >= 0; --i)
+                {
+                    if (_mergedDictionaries[i] is ISetResourceParent merged)
+                    {
+                        merged.ParentResourcesChanged(e);
+                    }
+                }
+            }
+        }
+
+        private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
+        {
+            var ev = new ResourcesChangedEventArgs();
+            NotifyMergedDictionariesResourcesChanged(ev);
+            OnResourcesChanged();
+        }
+
         private void MergedDictionaryResourcesChanged(object sender, ResourcesChangedEventArgs e) => OnResourcesChanged();
     }
 }
diff --git a/src/Avalonia.Styling/StyledElement.cs b/src/Avalonia.Styling/StyledElement.cs
index 5e1bcde2f6..b5deb9a4a1 100644
--- a/src/Avalonia.Styling/StyledElement.cs
+++ b/src/Avalonia.Styling/StyledElement.cs
@@ -223,13 +223,13 @@ namespace Avalonia
                 {
                     if (_styles != null)
                     {
-                        (_styles as ISetStyleParent)?.SetParent(null);
+                        (_styles as ISetResourceParent)?.SetParent(null);
                         _styles.ResourcesChanged -= ThisResourcesChanged;
                     }
 
                     _styles = value;
 
-                    if (value is ISetStyleParent setParent && setParent.ResourceParent == null)
+                    if (value is ISetResourceParent setParent && setParent.ResourceParent == null)
                     {
                         setParent.SetParent(this);
                     }
diff --git a/src/Avalonia.Styling/Styling/Style.cs b/src/Avalonia.Styling/Styling/Style.cs
index 3ce82b4160..99ee8d8563 100644
--- a/src/Avalonia.Styling/Styling/Style.cs
+++ b/src/Avalonia.Styling/Styling/Style.cs
@@ -14,7 +14,7 @@ namespace Avalonia.Styling
     /// <summary>
     /// Defines a style.
     /// </summary>
-    public class Style : AvaloniaObject, IStyle, ISetStyleParent
+    public class Style : AvaloniaObject, IStyle, ISetResourceParent
     {
         private static Dictionary<IStyleable, CompositeDisposable> _applied =
             new Dictionary<IStyleable, CompositeDisposable>();
@@ -59,16 +59,16 @@ namespace Avalonia.Styling
 
                 if (_resources != null)
                 {
-                    hadResources = _resources.Count > 0;
+                    hadResources = _resources.HasResources;
                     _resources.ResourcesChanged -= ResourceDictionaryChanged;
                 }
 
                 _resources = value;
                 _resources.ResourcesChanged += ResourceDictionaryChanged;
 
-                if (hadResources || _resources.Count > 0)
+                if (hadResources || _resources.HasResources)
                 {
-                    ((ISetStyleParent)this).NotifyResourcesChanged(new ResourcesChangedEventArgs());
+                    ((ISetResourceParent)this).ParentResourcesChanged(new ResourcesChangedEventArgs());
                 }
             }
         }
@@ -194,13 +194,13 @@ namespace Avalonia.Styling
         }
 
         /// <inheritdoc/>
-        void ISetStyleParent.NotifyResourcesChanged(ResourcesChangedEventArgs e)
+        void ISetResourceParent.ParentResourcesChanged(ResourcesChangedEventArgs e)
         {
             ResourcesChanged?.Invoke(this, e);
         }
 
         /// <inheritdoc/>
-        void ISetStyleParent.SetParent(IResourceNode parent)
+        void ISetResourceParent.SetParent(IResourceNode parent)
         {
             if (_parent != null && parent != null)
             {
diff --git a/src/Avalonia.Styling/Styling/Styles.cs b/src/Avalonia.Styling/Styling/Styles.cs
index a4563110a9..0226288998 100644
--- a/src/Avalonia.Styling/Styling/Styles.cs
+++ b/src/Avalonia.Styling/Styling/Styles.cs
@@ -14,7 +14,7 @@ namespace Avalonia.Styling
     /// <summary>
     /// A style that consists of a number of child styles.
     /// </summary>
-    public class Styles : AvaloniaObject, IAvaloniaList<IStyle>, IStyle, ISetStyleParent
+    public class Styles : AvaloniaObject, IAvaloniaList<IStyle>, IStyle, ISetResourceParent
     {
         private IResourceNode _parent;
         private IResourceDictionary _resources;
@@ -27,10 +27,10 @@ namespace Avalonia.Styling
             _styles.ForEachItem(
                 x =>
                 {
-                    if (x.ResourceParent == null && x is ISetStyleParent setParent)
+                    if (x.ResourceParent == null && x is ISetResourceParent setParent)
                     {
                         setParent.SetParent(this);
-                        setParent.NotifyResourcesChanged(new ResourcesChangedEventArgs());
+                        setParent.ParentResourcesChanged(new ResourcesChangedEventArgs());
                     }
 
                     if (x.HasResources)
@@ -43,10 +43,10 @@ namespace Avalonia.Styling
                 },
                 x =>
                 {
-                    if (x.ResourceParent == this && x is ISetStyleParent setParent)
+                    if (x.ResourceParent == this && x is ISetResourceParent setParent)
                     {
                         setParent.SetParent(null);
-                        setParent.NotifyResourcesChanged(new ResourcesChangedEventArgs());
+                        setParent.ParentResourcesChanged(new ResourcesChangedEventArgs());
                     }
 
                     if (x.HasResources)
@@ -98,7 +98,7 @@ namespace Avalonia.Styling
 
                 if (hadResources || _resources.Count > 0)
                 {
-                    ((ISetStyleParent)this).NotifyResourcesChanged(new ResourcesChangedEventArgs());
+                    ((ISetResourceParent)this).ParentResourcesChanged(new ResourcesChangedEventArgs());
                 }
             }
         }
@@ -246,7 +246,7 @@ namespace Avalonia.Styling
         IEnumerator IEnumerable.GetEnumerator() => _styles.GetEnumerator();
 
         /// <inheritdoc/>
-        void ISetStyleParent.SetParent(IResourceNode parent)
+        void ISetResourceParent.SetParent(IResourceNode parent)
         {
             if (_parent != null && parent != null)
             {
@@ -257,7 +257,7 @@ namespace Avalonia.Styling
         }
 
         /// <inheritdoc/>
-        void ISetStyleParent.NotifyResourcesChanged(ResourcesChangedEventArgs e)
+        void ISetResourceParent.ParentResourcesChanged(ResourcesChangedEventArgs e)
         {
             ResourcesChanged?.Invoke(this, e);
         }
@@ -266,7 +266,7 @@ namespace Avalonia.Styling
         {
             foreach (var child in this)
             {
-                (child as ISetStyleParent)?.NotifyResourcesChanged(e);
+                (child as ISetResourceParent)?.ParentResourcesChanged(e);
             }
 
             ResourcesChanged?.Invoke(this, e);
@@ -280,7 +280,7 @@ namespace Avalonia.Styling
             {
                 if (foundSource)
                 {
-                    (child as ISetStyleParent)?.NotifyResourcesChanged(e);
+                    (child as ISetResourceParent)?.ParentResourcesChanged(e);
                 }
 
                 foundSource |= child == sender;
diff --git a/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/ResourceInclude.cs b/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/ResourceInclude.cs
index 3525628a79..0d56942645 100644
--- a/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/ResourceInclude.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/ResourceInclude.cs
@@ -7,8 +7,9 @@ namespace Avalonia.Markup.Xaml.MarkupExtensions
     /// <summary>
     /// Loads a resource dictionary from a specified URL.
     /// </summary>
-    public class ResourceInclude :IResourceProvider
+    public class ResourceInclude : IResourceNode, ISetResourceParent
     {
+        private IResourceNode _parent;
         private Uri _baseUri;
         private IResourceDictionary _loaded;
 
@@ -26,6 +27,9 @@ namespace Avalonia.Markup.Xaml.MarkupExtensions
                     var loader = new AvaloniaXamlLoader();
                     _loaded = (IResourceDictionary)loader.Load(Source, _baseUri);
 
+                    (_loaded as ISetResourceParent)?.SetParent(this);
+                    _loaded.ResourcesChanged += ResourcesChanged;
+
                     if (_loaded.HasResources)
                     {
                         ResourcesChanged?.Invoke(this, new ResourcesChangedEventArgs());
@@ -44,12 +48,32 @@ namespace Avalonia.Markup.Xaml.MarkupExtensions
         /// <inhertidoc/>
         bool IResourceProvider.HasResources => Loaded.HasResources;
 
+        /// <inhertidoc/>
+        IResourceNode IResourceNode.ResourceParent => _parent;
+
         /// <inhertidoc/>
         bool IResourceProvider.TryGetResource(object key, out object value)
         {
             return Loaded.TryGetResource(key, out value);
         }
 
+        /// <inhertidoc/>
+        void ISetResourceParent.SetParent(IResourceNode parent)
+        {
+            if (_parent != null && parent != null)
+            {
+                throw new InvalidOperationException("The ResourceInclude already has a parent.");
+            }
+
+            _parent = parent;
+        }
+
+        /// <inhertidoc/>
+        void ISetResourceParent.ParentResourcesChanged(ResourcesChangedEventArgs e)
+        {
+            (_loaded as ISetResourceParent)?.ParentResourcesChanged(e);
+        }
+
         public ResourceInclude ProvideValue(IServiceProvider serviceProvider)
         {
             var tdc = (ITypeDescriptorContext)serviceProvider;
diff --git a/src/Markup/Avalonia.Markup.Xaml/Styling/StyleInclude.cs b/src/Markup/Avalonia.Markup.Xaml/Styling/StyleInclude.cs
index 7acee50d80..41eab79ed8 100644
--- a/src/Markup/Avalonia.Markup.Xaml/Styling/StyleInclude.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/Styling/StyleInclude.cs
@@ -10,7 +10,7 @@ namespace Avalonia.Markup.Xaml.Styling
     /// <summary>
     /// Includes a style from a URL.
     /// </summary>
-    public class StyleInclude : IStyle, ISetStyleParent
+    public class StyleInclude : IStyle, ISetResourceParent
     {
         private Uri _baseUri;
         private IStyle _loaded;
@@ -53,7 +53,7 @@ namespace Avalonia.Markup.Xaml.Styling
                 {
                     var loader = new AvaloniaXamlLoader();
                     _loaded = (IStyle)loader.Load(Source, _baseUri);
-                    (_loaded as ISetStyleParent)?.SetParent(this);
+                    (_loaded as ISetResourceParent)?.SetParent(this);
                 }
 
                 return _loaded;
@@ -89,13 +89,13 @@ namespace Avalonia.Markup.Xaml.Styling
         public bool TryGetResource(object key, out object value) => Loaded.TryGetResource(key, out value);
 
         /// <inheritdoc/>
-        void ISetStyleParent.NotifyResourcesChanged(ResourcesChangedEventArgs e)
+        void ISetResourceParent.ParentResourcesChanged(ResourcesChangedEventArgs e)
         {
-            (Loaded as ISetStyleParent)?.NotifyResourcesChanged(e);
+            (Loaded as ISetResourceParent)?.ParentResourcesChanged(e);
         }
 
         /// <inheritdoc/>
-        void ISetStyleParent.SetParent(IResourceNode parent)
+        void ISetResourceParent.SetParent(IResourceNode parent)
         {
             if (_parent != null && parent != null)
             {
diff --git a/tests/Avalonia.Styling.UnitTests/ResourceDictionaryTests.cs b/tests/Avalonia.Styling.UnitTests/ResourceDictionaryTests.cs
index 1eb3cd9750..56316b0cea 100644
--- a/tests/Avalonia.Styling.UnitTests/ResourceDictionaryTests.cs
+++ b/tests/Avalonia.Styling.UnitTests/ResourceDictionaryTests.cs
@@ -3,6 +3,7 @@
 
 using System;
 using Avalonia.Controls;
+using Moq;
 using Xunit;
 
 namespace Avalonia.Styling.UnitTests
@@ -136,7 +137,7 @@ namespace Avalonia.Styling.UnitTests
         }
 
         [Fact]
-        public void ResourcesChanged_Should_Not_Be_Raised_On_Empty_MergedDictionary_Remove()
+        public void ResourcesChanged_Should_Be_Raised_On_MergedDictionary_Resource_Add()
         {
             var target = new ResourceDictionary
             {
@@ -145,31 +146,45 @@ namespace Avalonia.Styling.UnitTests
                     new ResourceDictionary(),
                 }
             };
+
             var raised = false;
 
             target.ResourcesChanged += (_, __) => raised = true;
-            target.MergedDictionaries.RemoveAt(0);
+            ((IResourceDictionary)target.MergedDictionaries[0]).Add("foo", "bar");
 
-            Assert.False(raised);
+            Assert.True(raised);
         }
 
         [Fact]
-        public void ResourcesChanged_Should_Be_Raised_On_MergedDictionary_Resource_Add()
+        public void MergedDictionary_ParentResourcesChanged_Should_Be_Called_On_Resource_Add()
         {
-            var target = new ResourceDictionary
-            {
-                MergedDictionaries =
-                {
-                    new ResourceDictionary(),
-                }
-            };
+            var target = new ResourceDictionary();
+            var merged = new Mock<ISetResourceParent>();
 
-            var raised = false;
+            target.MergedDictionaries.Add(merged.Object);
+            merged.ResetCalls();
 
-            target.ResourcesChanged += (_, __) => raised = true;
-            ((IResourceDictionary)target.MergedDictionaries[0]).Add("foo", "bar");
+            target.Add("foo", "bar");
 
-            Assert.True(raised);
+            merged.Verify(
+                x => x.ParentResourcesChanged(It.IsAny<ResourcesChangedEventArgs>()),
+                Times.Once);
+        }
+
+        [Fact]
+        public void MergedDictionary_ParentResourcesChanged_Should_Be_Called_On_NotifyResourceChanged()
+        {
+            var target = new ResourceDictionary();
+            var merged = new Mock<ISetResourceParent>();
+
+            target.MergedDictionaries.Add(merged.Object);
+            merged.ResetCalls();
+
+            ((ISetResourceParent)target).ParentResourcesChanged(new ResourcesChangedEventArgs());
+
+            merged.Verify(
+                x => x.ParentResourcesChanged(It.IsAny<ResourcesChangedEventArgs>()),
+                Times.Once);
         }
     }
 }

From b773238c0e19563841e67658dde50406fbe86e77 Mon Sep 17 00:00:00 2001
From: macpawluk <macpawluk@gmail.com>
Date: Wed, 11 Dec 2019 08:39:19 +0100
Subject: [PATCH 03/46] Unit tests covering issues of ImmediateRenderer with
 transformed children

---
 .../Rendering/ImmediateRendererTests.cs       | 136 ++++++++++++++++++
 1 file changed, 136 insertions(+)

diff --git a/tests/Avalonia.Visuals.UnitTests/Rendering/ImmediateRendererTests.cs b/tests/Avalonia.Visuals.UnitTests/Rendering/ImmediateRendererTests.cs
index 73e4a14539..69c3f124e0 100644
--- a/tests/Avalonia.Visuals.UnitTests/Rendering/ImmediateRendererTests.cs
+++ b/tests/Avalonia.Visuals.UnitTests/Rendering/ImmediateRendererTests.cs
@@ -178,5 +178,141 @@ namespace Avalonia.Visuals.UnitTests.Rendering
 
             Assert.Equal(1, rendered);
         }
+
+        [Fact]
+        public void Should_Not_Clip_Children_With_RenderTransform_When_In_Bounds()
+        {
+            const int RootWidth = 300;
+            const int RootHeight = 300;
+
+            var rootGrid = new Grid
+            {
+                Width = RootWidth,
+                Height = RootHeight,
+                ClipToBounds = true
+            };
+
+            var stackPanel = new StackPanel
+            {
+                Orientation = Orientation.Horizontal,
+                VerticalAlignment = VerticalAlignment.Top,
+                HorizontalAlignment = HorizontalAlignment.Right,
+                Margin = new Thickness(0, 10, 0, 0),
+                RenderTransformOrigin = new RelativePoint(new Point(0, 0), RelativeUnit.Relative),
+                RenderTransform = new TransformGroup
+                {
+                    Children =
+                    {
+                        new RotateTransform { Angle = 90 },
+                        new TranslateTransform { X = 240 }
+                    }
+                }
+            };
+
+            rootGrid.Children.Add(stackPanel);
+
+            TestControl CreateControl()
+                => new TestControl
+                {
+                    Width = 80,
+                    Height = 40,
+                    Margin = new Thickness(0, 0, 5, 0),
+                    ClipToBounds = true
+                };
+
+            var control1 = CreateControl();
+            var control2 = CreateControl();
+            var control3 = CreateControl();
+
+            stackPanel.Children.Add(control1);
+            stackPanel.Children.Add(control2);
+            stackPanel.Children.Add(control3);
+
+            var root = new TestRoot(rootGrid);
+            root.Renderer = new ImmediateRenderer(root);
+            root.LayoutManager.ExecuteInitialLayoutPass(root);
+
+            var rootSize = new Size(RootWidth, RootHeight);
+            root.Measure(rootSize);
+            root.Arrange(new Rect(rootSize));
+
+            root.Renderer.Paint(root.Bounds);
+
+            Assert.True(control1.Rendered);
+            Assert.True(control2.Rendered);
+            Assert.True(control3.Rendered);
+        }
+
+        [Fact]
+        public void Should_Not_Render_Clipped_Child_With_RenderTransform_When_Not_In_Bounds()
+        {
+            const int RootWidth = 300;
+            const int RootHeight = 300;
+
+            var rootGrid = new Grid
+            {
+                Width = RootWidth,
+                Height = RootHeight,
+                ClipToBounds = true
+            };
+
+            var stackPanel = new StackPanel
+            {
+                Orientation = Orientation.Horizontal,
+                VerticalAlignment = VerticalAlignment.Top,
+                HorizontalAlignment = HorizontalAlignment.Right,
+                Margin = new Thickness(0, 10, 0, 0),
+                RenderTransformOrigin = new RelativePoint(new Point(0, 0), RelativeUnit.Relative),
+                RenderTransform = new TransformGroup
+                {
+                    Children =
+                    {
+                        new RotateTransform { Angle = 90 },
+                        new TranslateTransform { X = 280 }
+                    }
+                }
+            };
+
+            rootGrid.Children.Add(stackPanel);
+
+            TestControl CreateControl()
+                => new TestControl
+                {
+                    Width = 160,
+                    Height = 40,
+                    Margin = new Thickness(0, 0, 5, 0),
+                    ClipToBounds = true
+                };
+
+            var control1 = CreateControl();
+            var control2 = CreateControl();
+            var control3 = CreateControl();
+
+            stackPanel.Children.Add(control1);
+            stackPanel.Children.Add(control2);
+            stackPanel.Children.Add(control3);
+
+            var root = new TestRoot(rootGrid);
+            root.Renderer = new ImmediateRenderer(root);
+            root.LayoutManager.ExecuteInitialLayoutPass(root);
+
+            var rootSize = new Size(RootWidth, RootHeight);
+            root.Measure(rootSize);
+            root.Arrange(new Rect(rootSize));
+
+            root.Renderer.Paint(root.Bounds);
+
+            Assert.True(control1.Rendered);
+            Assert.True(control2.Rendered);
+            Assert.False(control3.Rendered);
+        }
+
+        private class TestControl : Control
+        {
+            public bool Rendered { get; private set; }
+
+            public override void Render(DrawingContext context)
+                => Rendered = true;
+        }
     }
 }

From 5a235a916fe3478c83740f16ce60a7eceaa19ca3 Mon Sep 17 00:00:00 2001
From: macpawluk <macpawluk@gmail.com>
Date: Wed, 11 Dec 2019 08:35:32 +0100
Subject: [PATCH 04/46] Fix ImmediateRenderer for children with transform

---
 src/Avalonia.Visuals/Rendering/ImmediateRenderer.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Visuals/Rendering/ImmediateRenderer.cs b/src/Avalonia.Visuals/Rendering/ImmediateRenderer.cs
index 68d56eeedd..5914bcb1fe 100644
--- a/src/Avalonia.Visuals/Rendering/ImmediateRenderer.cs
+++ b/src/Avalonia.Visuals/Rendering/ImmediateRenderer.cs
@@ -307,7 +307,9 @@ namespace Avalonia.Rendering
 
                         if (!child.ClipToBounds || clipRect.Intersects(childBounds))
                         {
-                            var childClipRect = clipRect.Translate(-childBounds.Position);
+                            var childClipRect = child.RenderTransform == null
+                                ? clipRect.Translate(-childBounds.Position)
+                                : clipRect;
                             Render(context, child, childClipRect);
                         }
                         else

From 36dd50e6458f9fe97872bb108913d595f04219ea Mon Sep 17 00:00:00 2001
From: Andrey Kunchev <donandren@gmail.com>
Date: Thu, 12 Dec 2019 14:46:34 +0200
Subject: [PATCH 05/46] fix immediate rendering hit testing for AdornerLayer

---
 src/Avalonia.Controls/Primitives/AdornerLayer.cs    |  5 +----
 .../Rendering/ICustomSimpleHitTest.cs               | 13 +++++++++++++
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/Avalonia.Controls/Primitives/AdornerLayer.cs b/src/Avalonia.Controls/Primitives/AdornerLayer.cs
index ebe5e0a93e..9a2f0310d7 100644
--- a/src/Avalonia.Controls/Primitives/AdornerLayer.cs
+++ b/src/Avalonia.Controls/Primitives/AdornerLayer.cs
@@ -138,10 +138,7 @@ namespace Avalonia.Controls.Primitives
             }
         }
 
-        public bool HitTest(Point point)
-        {
-            return Children.Any(ctrl => ctrl.TransformedBounds?.Contains(point) == true);
-        }
+        public bool HitTest(Point point) => Children.HitTestCustom(point);
 
         private class AdornedElementInfo
         {
diff --git a/src/Avalonia.Visuals/Rendering/ICustomSimpleHitTest.cs b/src/Avalonia.Visuals/Rendering/ICustomSimpleHitTest.cs
index 7199053b08..4c15de0312 100644
--- a/src/Avalonia.Visuals/Rendering/ICustomSimpleHitTest.cs
+++ b/src/Avalonia.Visuals/Rendering/ICustomSimpleHitTest.cs
@@ -1,3 +1,7 @@
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia.VisualTree;
+
 namespace Avalonia.Rendering
 {
     /// <summary>
@@ -9,4 +13,13 @@ namespace Avalonia.Rendering
     {
         bool HitTest(Point point);
     }
+
+    public static class CustomSimpleHitTestExtensions
+    {
+        public static bool HitTestCustom(this IVisual visual, Point point)
+            => (visual as ICustomSimpleHitTest)?.HitTest(point) ?? visual.TransformedBounds?.Contains(point) == true;
+
+        public static bool HitTestCustom(this IEnumerable<IVisual> children, Point point)
+            => children.Any(ctrl => ctrl.HitTestCustom(point));
+    }
 }

From fc44379173d3e2ecf74f4789b55a9002855f6968 Mon Sep 17 00:00:00 2001
From: Andrey Kunchev <donandren@gmail.com>
Date: Thu, 12 Dec 2019 14:59:17 +0200
Subject: [PATCH 06/46] fix immediaterenderer custom hittesting for
 WindowNotificationManager fixes #3356

---
 .../Notifications/WindowNotificationManager.cs               | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/Notifications/WindowNotificationManager.cs b/src/Avalonia.Controls/Notifications/WindowNotificationManager.cs
index 1a9347e317..f27bb5fac6 100644
--- a/src/Avalonia.Controls/Notifications/WindowNotificationManager.cs
+++ b/src/Avalonia.Controls/Notifications/WindowNotificationManager.cs
@@ -7,6 +7,7 @@ using System.Linq;
 using System.Reactive.Linq;
 using System.Threading.Tasks;
 using Avalonia.Controls.Primitives;
+using Avalonia.Rendering;
 using Avalonia.VisualTree;
 
 namespace Avalonia.Controls.Notifications
@@ -14,7 +15,7 @@ namespace Avalonia.Controls.Notifications
     /// <summary>
     /// An <see cref="INotificationManager"/> that displays notifications in a <see cref="Window"/>.
     /// </summary>
-    public class WindowNotificationManager : TemplatedControl, IManagedNotificationManager
+    public class WindowNotificationManager : TemplatedControl, IManagedNotificationManager, ICustomSimpleHitTest
     {
         private IList _items;
 
@@ -153,5 +154,7 @@ namespace Avalonia.Controls.Notifications
 
             adornerLayer?.Children.Add(this);
         }
+
+        public bool HitTest(Point point) => VisualChildren.HitTestCustom(point);
     }
 }

From 3439a371d940fe9b76adfa679393b170f9b499a3 Mon Sep 17 00:00:00 2001
From: Andrey Kunchev <donandren@gmail.com>
Date: Thu, 12 Dec 2019 15:01:10 +0200
Subject: [PATCH 07/46] sync custom hittesting also to overlaylayer

---
 src/Avalonia.Controls/Primitives/OverlayLayer.cs | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/Avalonia.Controls/Primitives/OverlayLayer.cs b/src/Avalonia.Controls/Primitives/OverlayLayer.cs
index 487a5e91e4..5150033a53 100644
--- a/src/Avalonia.Controls/Primitives/OverlayLayer.cs
+++ b/src/Avalonia.Controls/Primitives/OverlayLayer.cs
@@ -21,11 +21,8 @@ namespace Avalonia.Controls.Primitives
 
             return null;
         }
-        
-        public bool HitTest(Point point)
-        {
-            return Children.Any(ctrl => ctrl.TransformedBounds?.Contains(point) == true);
-        }
+
+        public bool HitTest(Point point) => Children.HitTestCustom(point);
         
         protected override Size ArrangeOverride(Size finalSize)
         {

From 6fabfdc5612657c3f0a63b1b70e59fc3cf52bc7b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Pedro?= <jpedrolmail@gmail.com>
Date: Fri, 13 Dec 2019 23:43:15 +0000
Subject: [PATCH 08/46] Fixed BindingExtension.TargetNullValue default value.

---
 .../MarkupExtensions/BindingExtension.cs      |  4 ++--
 .../MarkupExtensions/BindingExtensionTests.cs | 24 ++++++++++++++++++-
 2 files changed, 25 insertions(+), 3 deletions(-)

diff --git a/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/BindingExtension.cs b/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/BindingExtension.cs
index 3073f913f4..c77ccd64f2 100644
--- a/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/BindingExtension.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/MarkupExtensions/BindingExtension.cs
@@ -87,7 +87,7 @@ namespace Avalonia.Markup.Xaml.MarkupExtensions
         public string StringFormat { get; set; }
 
         public RelativeSource RelativeSource { get; set; }
-        
-        public object TargetNullValue { get; set; }
+
+        public object TargetNullValue { get; set; } = AvaloniaProperty.UnsetValue;
     }
 }
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/BindingExtensionTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/BindingExtensionTests.cs
index 88c8034e52..76edf9a17a 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/BindingExtensionTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/BindingExtensionTests.cs
@@ -38,7 +38,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions
                 Assert.Equal("foobar", textBlock.Text);
             }
         }
-        
+
         [Fact]
         public void BindingExtension_Binds_To_TargetNullValue()
         {
@@ -65,6 +65,28 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions
             }
         }
 
+        [Fact]
+        public void BindingExtension_TargetNullValue_UnsetByDefault()
+        {
+            using (StyledWindow())
+            {
+                var xaml = @"
+<Window xmlns='https://github.com/avaloniaui'
+        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
+    <TextBlock Name='textBlock' IsVisible='{Binding Foo, Converter={x:Static ObjectConverters.IsNotNull}}'/>
+</Window>";
+
+                var loader = new AvaloniaXamlLoader();
+                var window = (Window)loader.Load(xaml);
+                var textBlock = window.FindControl<TextBlock>("textBlock");
+
+                window.DataContext = new FooBar();
+                window.Show();
+
+                Assert.Equal(false, textBlock.IsVisible);
+            }
+        }
+
         private class FooBar
         {
             public object Foo { get; } = null;

From fb1dcc11b47446ba9b122c2a3b7e60ca11d3000f Mon Sep 17 00:00:00 2001
From: Pieter-Jan Briers <pieterjan.briers+git@gmail.com>
Date: Mon, 16 Dec 2019 20:45:52 +0100
Subject: [PATCH 09/46] Fix loading EGL functions on GLX.

This fixes apps refusing to run on Arch Linux.
---
 src/Avalonia.X11/Glx/Glx.cs        | 18 +++++++++++++++++-
 src/Avalonia.X11/Glx/GlxDisplay.cs |  2 +-
 2 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/src/Avalonia.X11/Glx/Glx.cs b/src/Avalonia.X11/Glx/Glx.cs
index c3a2fd2050..a059e92210 100644
--- a/src/Avalonia.X11/Glx/Glx.cs
+++ b/src/Avalonia.X11/Glx/Glx.cs
@@ -84,8 +84,24 @@ namespace Avalonia.X11.Glx
         [GlEntryPoint("glGetError")]
         public GlGetError GetError { get; }
 
-        public GlxInterface() : base(GlxGetProcAddress)
+        public GlxInterface() : base(SafeGetProcAddress)
         {
         }
+
+        // Ignores egl functions.
+        // On some Linux systems, glXGetProcAddress will return valid pointers for even EGL functions.
+        // This makes Skia try to load some data from EGL,
+        // which can then cause segmentation faults because they return garbage.
+        public static IntPtr SafeGetProcAddress(string proc, bool optional)
+        {
+            if (proc.StartsWith("egl"))
+            {
+                return IntPtr.Zero;
+            }
+
+            return GlxConverted(proc, optional);
+        }
+
+        private static readonly Func<string, bool, IntPtr> GlxConverted = ConvertNative(GlxGetProcAddress);
     }
 }
diff --git a/src/Avalonia.X11/Glx/GlxDisplay.cs b/src/Avalonia.X11/Glx/GlxDisplay.cs
index 04f2a7137c..22eb0792e8 100644
--- a/src/Avalonia.X11/Glx/GlxDisplay.cs
+++ b/src/Avalonia.X11/Glx/GlxDisplay.cs
@@ -87,7 +87,7 @@ namespace Avalonia.X11.Glx
             ImmediateContext.MakeCurrent();
             var err = Glx.GetError();
             
-            GlInterface = new GlInterface(GlxInterface.GlxGetProcAddress);
+            GlInterface = new GlInterface(GlxInterface.SafeGetProcAddress);
             if (GlInterface.Version == null)
                 throw new OpenGlException("GL version string is null, aborting");
             if (GlInterface.Renderer == null)

From fc5ada5e23dc01610ad59c6407db4c85fc7de8f9 Mon Sep 17 00:00:00 2001
From: Pieter-Jan Briers <pieterjan.briers+git@gmail.com>
Date: Tue, 17 Dec 2019 19:13:06 +0100
Subject: [PATCH 10/46] Use invariant culture.

---
 src/Avalonia.X11/Glx/Glx.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Avalonia.X11/Glx/Glx.cs b/src/Avalonia.X11/Glx/Glx.cs
index a059e92210..714a592f2b 100644
--- a/src/Avalonia.X11/Glx/Glx.cs
+++ b/src/Avalonia.X11/Glx/Glx.cs
@@ -94,7 +94,7 @@ namespace Avalonia.X11.Glx
         // which can then cause segmentation faults because they return garbage.
         public static IntPtr SafeGetProcAddress(string proc, bool optional)
         {
-            if (proc.StartsWith("egl"))
+            if (proc.StartsWith("egl", StringComparison.InvariantCulture))
             {
                 return IntPtr.Zero;
             }

From 4c2b77fdb6b738881520edebb31302d7eb2655bd Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 19 Dec 2019 15:37:37 +0100
Subject: [PATCH 11/46] Snapshot undo text after paste.

Fixes #2732
---
 src/Avalonia.Controls/TextBox.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Avalonia.Controls/TextBox.cs b/src/Avalonia.Controls/TextBox.cs
index 3d472fca18..c3eec851b9 100644
--- a/src/Avalonia.Controls/TextBox.cs
+++ b/src/Avalonia.Controls/TextBox.cs
@@ -390,8 +390,10 @@ namespace Avalonia.Controls
             {
                 return;
             }
+
             _undoRedoHelper.Snapshot();
             HandleTextInput(text);
+            _undoRedoHelper.Snapshot();
         }
 
         protected override void OnKeyDown(KeyEventArgs e)

From a0f72ff47ccd6864a31177fa351f7e90967222dd Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 19 Dec 2019 23:33:15 +0100
Subject: [PATCH 12/46] Added failing tests for #3371.

---
 .../Avalonia.Controls.UnitTests/ImageTests.cs | 57 ++++++++++++++++---
 1 file changed, 49 insertions(+), 8 deletions(-)

diff --git a/tests/Avalonia.Controls.UnitTests/ImageTests.cs b/tests/Avalonia.Controls.UnitTests/ImageTests.cs
index 71d0d1e328..666345da9c 100644
--- a/tests/Avalonia.Controls.UnitTests/ImageTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ImageTests.cs
@@ -13,7 +13,7 @@ namespace Avalonia.Controls.UnitTests
         [Fact]
         public void Measure_Should_Return_Correct_Size_For_No_Stretch()
         {
-            var bitmap = Mock.Of<IBitmap>(x => x.PixelSize == new PixelSize(50, 100));
+            var bitmap = CreateBitmap(50, 100);
             var target = new Image();
             target.Stretch = Stretch.None;
             target.Source = bitmap;
@@ -26,7 +26,7 @@ namespace Avalonia.Controls.UnitTests
         [Fact]
         public void Measure_Should_Return_Correct_Size_For_Fill_Stretch()
         {
-            var bitmap = Mock.Of<IBitmap>(x => x.PixelSize == new PixelSize(50, 100));
+            var bitmap = CreateBitmap(50, 100);
             var target = new Image();
             target.Stretch = Stretch.Fill;
             target.Source = bitmap;
@@ -39,7 +39,7 @@ namespace Avalonia.Controls.UnitTests
         [Fact]
         public void Measure_Should_Return_Correct_Size_For_Uniform_Stretch()
         {
-            var bitmap = Mock.Of<IBitmap>(x => x.PixelSize == new PixelSize(50, 100));
+            var bitmap = CreateBitmap(50, 100);
             var target = new Image();
             target.Stretch = Stretch.Uniform;
             target.Source = bitmap;
@@ -52,7 +52,7 @@ namespace Avalonia.Controls.UnitTests
         [Fact]
         public void Measure_Should_Return_Correct_Size_For_UniformToFill_Stretch()
         {
-            var bitmap = Mock.Of<IBitmap>(x => x.PixelSize == new PixelSize(50, 100));
+            var bitmap = CreateBitmap(50, 100);
             var target = new Image();
             target.Stretch = Stretch.UniformToFill;
             target.Source = bitmap;
@@ -62,10 +62,46 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(new Size(50, 50), target.DesiredSize);
         }
 
+        [Fact]
+        public void Measure_Should_Return_Correct_Size_For_Infinite_Height()
+        {
+            var bitmap = CreateBitmap(50, 100);
+            var image = new Image();
+            image.Source = bitmap;
+
+            image.Measure(new Size(200, double.PositiveInfinity));
+
+            Assert.Equal(new Size(200, 400), image.DesiredSize);
+        }
+
+        [Fact]
+        public void Measure_Should_Return_Correct_Size_For_Infinite_Width()
+        {
+            var bitmap = CreateBitmap(50, 100);
+            var image = new Image();
+            image.Source = bitmap;
+
+            image.Measure(new Size(double.PositiveInfinity, 400));
+
+            Assert.Equal(new Size(200, 400), image.DesiredSize);
+        }
+
+        [Fact]
+        public void Measure_Should_Return_Correct_Size_For_Infinite_Width_Height()
+        {
+            var bitmap = CreateBitmap(50, 100);
+            var image = new Image();
+            image.Source = bitmap;
+
+            image.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
+
+            Assert.Equal(new Size(50, 100), image.DesiredSize);
+        }
+
         [Fact]
         public void Arrange_Should_Return_Correct_Size_For_No_Stretch()
         {
-            var bitmap = Mock.Of<IBitmap>(x => x.PixelSize == new PixelSize(50, 100));
+            var bitmap = CreateBitmap(50, 100);
             var target = new Image();
             target.Stretch = Stretch.None;
             target.Source = bitmap;
@@ -79,7 +115,7 @@ namespace Avalonia.Controls.UnitTests
         [Fact]
         public void Arrange_Should_Return_Correct_Size_For_Fill_Stretch()
         {
-            var bitmap = Mock.Of<IBitmap>(x => x.PixelSize == new PixelSize(50, 100));
+            var bitmap = CreateBitmap(50, 100);
             var target = new Image();
             target.Stretch = Stretch.Fill;
             target.Source = bitmap;
@@ -93,7 +129,7 @@ namespace Avalonia.Controls.UnitTests
         [Fact]
         public void Arrange_Should_Return_Correct_Size_For_Uniform_Stretch()
         {
-            var bitmap = Mock.Of<IBitmap>(x => x.PixelSize == new PixelSize(50, 100));
+            var bitmap = CreateBitmap(50, 100);
             var target = new Image();
             target.Stretch = Stretch.Uniform;
             target.Source = bitmap;
@@ -107,7 +143,7 @@ namespace Avalonia.Controls.UnitTests
         [Fact]
         public void Arrange_Should_Return_Correct_Size_For_UniformToFill_Stretch()
         {
-            var bitmap = Mock.Of<IBitmap>(x => x.PixelSize == new PixelSize(50, 100));
+            var bitmap = CreateBitmap(50, 100);
             var target = new Image();
             target.Stretch = Stretch.UniformToFill;
             target.Source = bitmap;
@@ -117,5 +153,10 @@ namespace Avalonia.Controls.UnitTests
 
             Assert.Equal(new Size(25, 100), target.Bounds.Size);
         }
+
+        private IBitmap CreateBitmap(int width, int height)
+        {
+            return Mock.Of<IBitmap>(x => x.PixelSize == new PixelSize(width, height));
+        }
     }
 }

From 062ec0ccb6971645adbf540caca717399a0b703a Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 19 Dec 2019 23:46:26 +0100
Subject: [PATCH 13/46] Added Image.StretchDirection.

But not yet implemented.
---
 src/Avalonia.Controls/Image.cs                | 17 ++++++++++++-
 .../Media/StretchDirection.cs                 | 25 +++++++++++++++++++
 .../Avalonia.Controls.UnitTests/ImageTests.cs | 13 ++++++++++
 3 files changed, 54 insertions(+), 1 deletion(-)
 create mode 100644 src/Avalonia.Visuals/Media/StretchDirection.cs

diff --git a/src/Avalonia.Controls/Image.cs b/src/Avalonia.Controls/Image.cs
index ff6cd482df..fcbbd7e82b 100644
--- a/src/Avalonia.Controls/Image.cs
+++ b/src/Avalonia.Controls/Image.cs
@@ -23,6 +23,12 @@ namespace Avalonia.Controls
         public static readonly StyledProperty<Stretch> StretchProperty =
             AvaloniaProperty.Register<Image, Stretch>(nameof(Stretch), Stretch.Uniform);
 
+        /// <summary>
+        /// Defines the <see cref="StretchDirection"/> property.
+        /// </summary>
+        public static readonly StyledProperty<StretchDirection> StretchDirectionProperty =
+            AvaloniaProperty.Register<Image, StretchDirection>(nameof(StretchDirection));
+
         static Image()
         {
             AffectsRender<Image>(SourceProperty, StretchProperty);
@@ -43,10 +49,19 @@ namespace Avalonia.Controls
         /// </summary>
         public Stretch Stretch
         {
-            get { return (Stretch)GetValue(StretchProperty); }
+            get { return GetValue(StretchProperty); }
             set { SetValue(StretchProperty, value); }
         }
 
+        /// <summary>
+        /// Gets or sets a value controlling in what direction the image will be stretched.
+        /// </summary>
+        public StretchDirection StretchDirection
+        {
+            get { return GetValue(StretchDirectionProperty); }
+            set { SetValue(StretchDirectionProperty, value); }
+        }
+
         /// <summary>
         /// Renders the control.
         /// </summary>
diff --git a/src/Avalonia.Visuals/Media/StretchDirection.cs b/src/Avalonia.Visuals/Media/StretchDirection.cs
new file mode 100644
index 0000000000..a4be26f6cd
--- /dev/null
+++ b/src/Avalonia.Visuals/Media/StretchDirection.cs
@@ -0,0 +1,25 @@
+namespace Avalonia.Media
+{
+    /// <summary>
+    /// Describes the type of scaling that can be used when scaling content.
+    /// </summary>
+    public enum StretchDirection
+    {
+        /// <summary>
+        /// Only scales the content upwards when the content is smaller than the available space.
+        /// If the content is larger, no scaling downwards is done.
+        /// </summary>
+        UpOnly,
+
+        /// <summary>
+        /// Only scales the content downwards when the content is larger than the available space.
+        /// If the content is smaller, no scaling upwards is done.
+        /// </summary>
+        DownOnly,
+
+        /// <summary>
+        /// Always stretches to fit the available space according to the stretch mode.
+        /// </summary>
+        Both,
+    }
+}
diff --git a/tests/Avalonia.Controls.UnitTests/ImageTests.cs b/tests/Avalonia.Controls.UnitTests/ImageTests.cs
index 666345da9c..5102085fbf 100644
--- a/tests/Avalonia.Controls.UnitTests/ImageTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ImageTests.cs
@@ -62,6 +62,19 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(new Size(50, 50), target.DesiredSize);
         }
 
+        [Fact]
+        public void Measure_Should_Return_Correct_Size_With_StretchDirection_DownOnly()
+        {
+            var bitmap = CreateBitmap(50, 100);
+            var target = new Image();
+            target.StretchDirection = StretchDirection.DownOnly;
+            target.Source = bitmap;
+
+            target.Measure(new Size(150, 150));
+
+            Assert.Equal(new Size(50, 100), target.DesiredSize);
+        }
+
         [Fact]
         public void Measure_Should_Return_Correct_Size_For_Infinite_Height()
         {

From 4d8266df9c260827d9dc599f741de0f99350b36b Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 20 Dec 2019 00:10:16 +0100
Subject: [PATCH 14/46] Port Image sizing algorithm from WPF.

Fixes #3371
Fixes #2380
---
 src/Avalonia.Controls/Image.cs                | 17 ++--
 src/Avalonia.Visuals/Media/MediaExtensions.cs | 90 ++++++++++++++++---
 2 files changed, 83 insertions(+), 24 deletions(-)

diff --git a/src/Avalonia.Controls/Image.cs b/src/Avalonia.Controls/Image.cs
index fcbbd7e82b..c2cdcb4e69 100644
--- a/src/Avalonia.Controls/Image.cs
+++ b/src/Avalonia.Controls/Image.cs
@@ -27,7 +27,9 @@ namespace Avalonia.Controls
         /// Defines the <see cref="StretchDirection"/> property.
         /// </summary>
         public static readonly StyledProperty<StretchDirection> StretchDirectionProperty =
-            AvaloniaProperty.Register<Image, StretchDirection>(nameof(StretchDirection));
+            AvaloniaProperty.Register<Image, StretchDirection>(
+                nameof(StretchDirection),
+                StretchDirection.Both);
 
         static Image()
         {
@@ -74,7 +76,7 @@ namespace Avalonia.Controls
             {
                 Rect viewPort = new Rect(Bounds.Size);
                 Size sourceSize = new Size(source.PixelSize.Width, source.PixelSize.Height);
-                Vector scale = Stretch.CalculateScaling(Bounds.Size, sourceSize);
+                Vector scale = Stretch.CalculateScaling(Bounds.Size, sourceSize, StretchDirection);
                 Size scaledSize = sourceSize * scale;
                 Rect destRect = viewPort
                     .CenterRect(new Rect(scaledSize))
@@ -100,15 +102,8 @@ namespace Avalonia.Controls
 
             if (source != null)
             {
-                Size sourceSize = new Size(source.PixelSize.Width, source.PixelSize.Height);
-                if (double.IsInfinity(availableSize.Width) || double.IsInfinity(availableSize.Height))
-                {
-                    result = sourceSize;
-                }
-                else
-                {
-                    result = Stretch.CalculateSize(availableSize, sourceSize);
-                }
+                var sourceSize = new Size(source.PixelSize.Width, source.PixelSize.Height);
+                result = Stretch.CalculateSize(availableSize, sourceSize, StretchDirection);
             }
 
             return result;
diff --git a/src/Avalonia.Visuals/Media/MediaExtensions.cs b/src/Avalonia.Visuals/Media/MediaExtensions.cs
index 95d17b454e..36bda5f483 100644
--- a/src/Avalonia.Visuals/Media/MediaExtensions.cs
+++ b/src/Avalonia.Visuals/Media/MediaExtensions.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using System;
+using Avalonia.Utilities;
 
 namespace Avalonia.Media
 {
@@ -16,24 +17,82 @@ namespace Avalonia.Media
         /// <param name="stretch">The stretch mode.</param>
         /// <param name="destinationSize">The size of the destination viewport.</param>
         /// <param name="sourceSize">The size of the source.</param>
+        /// <param name="stretchDirection">The stretch direction.</param>
         /// <returns>A vector with the X and Y scaling factors.</returns>
-        public static Vector CalculateScaling(this Stretch stretch, Size destinationSize, Size sourceSize)
+        public static Vector CalculateScaling(
+            this Stretch stretch,
+            Size destinationSize,
+            Size sourceSize,
+            StretchDirection stretchDirection = StretchDirection.Both)
         {
-            double scaleX = 1;
-            double scaleY = 1;
+            var scaleX = 1.0;
+            var scaleY = 1.0;
 
-            if (stretch != Stretch.None)
+            bool isConstrainedWidth = !double.IsPositiveInfinity(destinationSize.Width);
+            bool isConstrainedHeight = !double.IsPositiveInfinity(destinationSize.Height);
+
+            if ((stretch == Stretch.Uniform || stretch == Stretch.UniformToFill || stretch == Stretch.Fill)
+                 && (isConstrainedWidth || isConstrainedHeight))
             {
-                scaleX = destinationSize.Width / sourceSize.Width;
-                scaleY = destinationSize.Height / sourceSize.Height;
+                // Compute scaling factors for both axes
+                scaleX = MathUtilities.IsZero(sourceSize.Width) ? 0.0 : destinationSize.Width / sourceSize.Width;
+                scaleY = MathUtilities.IsZero(sourceSize.Height) ? 0.0 : destinationSize.Height / sourceSize.Height;
 
-                switch (stretch)
+                if (!isConstrainedWidth)
+                {
+                    scaleX = scaleY;
+                }
+                else if (!isConstrainedHeight)
+                {
+                    scaleY = scaleX;
+                }
+                else
                 {
-                    case Stretch.Uniform:
-                        scaleX = scaleY = Math.Min(scaleX, scaleY);
+                    // If not preserving aspect ratio, then just apply transform to fit
+                    switch (stretch)
+                    {
+                        case Stretch.Uniform:
+                            // Find minimum scale that we use for both axes
+                            double minscale = scaleX < scaleY ? scaleX : scaleY;
+                            scaleX = scaleY = minscale;
+                            break;
+
+                        case Stretch.UniformToFill:
+                            // Find maximum scale that we use for both axes
+                            double maxscale = scaleX > scaleY ? scaleX : scaleY;
+                            scaleX = scaleY = maxscale;
+                            break;
+
+                        case Stretch.Fill:
+                            // We already computed the fill scale factors above, so just use them
+                            break;
+                    }
+                }
+
+                // Apply stretch direction by bounding scales.
+                // In the uniform case, scaleX=scaleY, so this sort of clamping will maintain aspect ratio
+                // In the uniform fill case, we have the same result too.
+                // In the fill case, note that we change aspect ratio, but that is okay
+                switch (stretchDirection)
+                {
+                    case StretchDirection.UpOnly:
+                        if (scaleX < 1.0)
+                            scaleX = 1.0;
+                        if (scaleY < 1.0)
+                            scaleY = 1.0;
+                        break;
+
+                    case StretchDirection.DownOnly:
+                        if (scaleX > 1.0)
+                            scaleX = 1.0;
+                        if (scaleY > 1.0)
+                            scaleY = 1.0;
                         break;
-                    case Stretch.UniformToFill:
-                        scaleX = scaleY = Math.Max(scaleX, scaleY);
+
+                    case StretchDirection.Both:
+                        break;
+
+                    default:
                         break;
                 }
             }
@@ -47,10 +106,15 @@ namespace Avalonia.Media
         /// <param name="stretch">The stretch mode.</param>
         /// <param name="destinationSize">The size of the destination viewport.</param>
         /// <param name="sourceSize">The size of the source.</param>
+        /// <param name="stretchDirection">The stretch direction.</param>
         /// <returns>The size of the stretched source.</returns>
-        public static Size CalculateSize(this Stretch stretch, Size destinationSize, Size sourceSize)
+        public static Size CalculateSize(
+            this Stretch stretch,
+            Size destinationSize,
+            Size sourceSize,
+            StretchDirection stretchDirection = StretchDirection.Both)
         {
-            return sourceSize * stretch.CalculateScaling(destinationSize, sourceSize);
+            return sourceSize * stretch.CalculateScaling(destinationSize, sourceSize, stretchDirection);
         }
     }
 }

From a8e75384b7a4e0754809779220ab742d37f49bf5 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 19 Dec 2019 17:29:46 +0100
Subject: [PATCH 15/46] Added IImage interface.

`IImage` represents a base interface for raster and vector images. `IBitmap` now implements this interface and `DrawingContext` accepts this interface in `DrawImage`.

The interface defines a `Draw` method which introduces a level of indirection for drawing the image through the image itself.

Renamed `IDrawingContextImpl.DrawImage` to `DrawBitmap` as this only handles drawing bitmap images. `Bitmap` now calls this method directly on the platform implementation.
---
 src/Avalonia.Visuals/Media/DrawingContext.cs  |  8 ++---
 src/Avalonia.Visuals/Media/IImage.cs          | 31 +++++++++++++++++++
 src/Avalonia.Visuals/Media/Imaging/Bitmap.cs  | 21 +++++++++++++
 src/Avalonia.Visuals/Media/Imaging/IBitmap.cs | 11 +------
 .../Platform/IDrawingContextImpl.cs           |  4 +--
 .../Rendering/DeferredRenderer.cs             |  6 ++--
 .../SceneGraph/DeferredDrawingContextImpl.cs  |  4 +--
 .../Rendering/SceneGraph/ImageNode.cs         |  2 +-
 src/Avalonia.X11/X11IconLoader.cs             |  2 +-
 src/Skia/Avalonia.Skia/DrawingContextImpl.cs  |  8 ++---
 .../Media/DrawingContextImpl.cs               |  4 +--
 .../Media/ImageBrushImpl.cs                   |  2 +-
 .../Imaging/D2DRenderTargetBitmapImpl.cs      |  2 +-
 .../Avalonia.RenderTests/Media/BitmapTests.cs |  2 +-
 .../Rendering/DeferredRendererTests.cs        |  2 +-
 15 files changed, 76 insertions(+), 33 deletions(-)
 create mode 100644 src/Avalonia.Visuals/Media/IImage.cs

diff --git a/src/Avalonia.Visuals/Media/DrawingContext.cs b/src/Avalonia.Visuals/Media/DrawingContext.cs
index df69ab6fd5..32fdf3b69a 100644
--- a/src/Avalonia.Visuals/Media/DrawingContext.cs
+++ b/src/Avalonia.Visuals/Media/DrawingContext.cs
@@ -74,18 +74,18 @@ namespace Avalonia.Media
         public Matrix CurrentContainerTransform => _currentContainerTransform;
 
         /// <summary>
-        /// Draws a bitmap image.
+        /// Draws an image.
         /// </summary>
-        /// <param name="source">The bitmap image.</param>
+        /// <param name="source">The image.</param>
         /// <param name="opacity">The opacity to draw with.</param>
         /// <param name="sourceRect">The rect in the image to draw.</param>
         /// <param name="destRect">The rect in the output to draw to.</param>
         /// <param name="bitmapInterpolationMode">The bitmap interpolation mode.</param>
-        public void DrawImage(IBitmap source, double opacity, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode = default)
+        public void DrawImage(IImage source, double opacity, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode = default)
         {
             Contract.Requires<ArgumentNullException>(source != null);
 
-            PlatformImpl.DrawImage(source.PlatformImpl, opacity, sourceRect, destRect, bitmapInterpolationMode);
+            source.Draw(this, opacity, sourceRect, destRect, bitmapInterpolationMode);
         }
 
         /// <summary>
diff --git a/src/Avalonia.Visuals/Media/IImage.cs b/src/Avalonia.Visuals/Media/IImage.cs
new file mode 100644
index 0000000000..35ddf07f44
--- /dev/null
+++ b/src/Avalonia.Visuals/Media/IImage.cs
@@ -0,0 +1,31 @@
+using Avalonia.Platform;
+using Avalonia.Visuals.Media.Imaging;
+
+namespace Avalonia.Media
+{
+    /// <summary>
+    /// Represents a raster or vector image.
+    /// </summary>
+    public interface IImage
+    {
+        /// <summary>
+        /// Gets the size of the image, in device independent pixels.
+        /// </summary>
+        Size Size { get; }
+
+        /// <summary>
+        /// Draws the image to a <see cref="DrawingContext"/>.
+        /// </summary>
+        /// <param name="context">The drawing context.</param>
+        /// <param name="opacity">The opacity to draw with.</param>
+        /// <param name="sourceRect">The rect in the image to draw.</param>
+        /// <param name="destRect">The rect in the output to draw to.</param>
+        /// <param name="bitmapInterpolationMode">The bitmap interpolation mode.</param>
+        void Draw(
+            DrawingContext context,
+            double opacity,
+            Rect sourceRect,
+            Rect destRect,
+            BitmapInterpolationMode bitmapInterpolationMode);
+    }
+}
diff --git a/src/Avalonia.Visuals/Media/Imaging/Bitmap.cs b/src/Avalonia.Visuals/Media/Imaging/Bitmap.cs
index 8dd75d2374..8f154ad8e4 100644
--- a/src/Avalonia.Visuals/Media/Imaging/Bitmap.cs
+++ b/src/Avalonia.Visuals/Media/Imaging/Bitmap.cs
@@ -5,6 +5,7 @@ using System;
 using System.IO;
 using Avalonia.Platform;
 using Avalonia.Utilities;
+using Avalonia.Visuals.Media.Imaging;
 
 namespace Avalonia.Media.Imaging
 {
@@ -94,9 +95,29 @@ namespace Avalonia.Media.Imaging
             PlatformImpl.Item.Save(fileName);
         }
 
+        /// <summary>
+        /// Saves the bitmap to a stream.
+        /// </summary>
+        /// <param name="stream">The stream.</param>
         public void Save(Stream stream)
         {
             PlatformImpl.Item.Save(stream);
         }
+
+        /// <inheritdoc/>
+        void IImage.Draw(
+            DrawingContext context,
+            double opacity,
+            Rect sourceRect,
+            Rect destRect,
+            BitmapInterpolationMode bitmapInterpolationMode)
+        {
+            context.PlatformImpl.DrawBitmap(
+                PlatformImpl,
+                opacity,
+                sourceRect,
+                destRect,
+                bitmapInterpolationMode);
+        }
     }
 }
diff --git a/src/Avalonia.Visuals/Media/Imaging/IBitmap.cs b/src/Avalonia.Visuals/Media/Imaging/IBitmap.cs
index 90b13088e1..4c3203a95b 100644
--- a/src/Avalonia.Visuals/Media/Imaging/IBitmap.cs
+++ b/src/Avalonia.Visuals/Media/Imaging/IBitmap.cs
@@ -11,7 +11,7 @@ namespace Avalonia.Media.Imaging
     /// <summary>
     /// Represents a bitmap image.
     /// </summary>
-    public interface IBitmap : IDisposable
+    public interface IBitmap : IImage, IDisposable
     {
         /// <summary>
         /// Gets the dots per inch (DPI) of the image.
@@ -32,15 +32,6 @@ namespace Avalonia.Media.Imaging
         /// </summary>
         IRef<IBitmapImpl> PlatformImpl { get; }
 
-        /// <summary>
-        /// Gets the size of the image, in device independent pixels.
-        /// </summary>
-        /// <remarks>
-        /// Note that Skia does not currently support reading the DPI of an image so this value
-        /// will equal <see cref="PixelSize"/> on Skia.
-        /// </remarks>
-        Size Size { get; }
-
         /// <summary>
         /// Saves the bitmap to a file.
         /// </summary>
diff --git a/src/Avalonia.Visuals/Platform/IDrawingContextImpl.cs b/src/Avalonia.Visuals/Platform/IDrawingContextImpl.cs
index f2309c271d..7d142b0759 100644
--- a/src/Avalonia.Visuals/Platform/IDrawingContextImpl.cs
+++ b/src/Avalonia.Visuals/Platform/IDrawingContextImpl.cs
@@ -33,7 +33,7 @@ namespace Avalonia.Platform
         /// <param name="sourceRect">The rect in the image to draw.</param>
         /// <param name="destRect">The rect in the output to draw to.</param>
         /// <param name="bitmapInterpolationMode">The bitmap interpolation mode.</param>
-        void DrawImage(IRef<IBitmapImpl> source, double opacity, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode = BitmapInterpolationMode.Default);
+        void DrawBitmap(IRef<IBitmapImpl> source, double opacity, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode = BitmapInterpolationMode.Default);
 
         /// <summary>
         /// Draws a bitmap image.
@@ -42,7 +42,7 @@ namespace Avalonia.Platform
         /// <param name="opacityMask">The opacity mask to draw with.</param>
         /// <param name="opacityMaskRect">The destination rect for the opacity mask.</param>
         /// <param name="destRect">The rect in the output to draw to.</param>
-        void DrawImage(IRef<IBitmapImpl> source, IBrush opacityMask, Rect opacityMaskRect, Rect destRect);
+        void DrawBitmap(IRef<IBitmapImpl> source, IBrush opacityMask, Rect opacityMaskRect, Rect destRect);
 
         /// <summary>
         /// Draws a line.
diff --git a/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs b/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs
index 2fa249f101..585b132bd3 100644
--- a/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs
+++ b/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs
@@ -469,11 +469,11 @@ namespace Avalonia.Rendering
 
                 if (layer.OpacityMask == null)
                 {
-                    context.DrawImage(bitmap, layer.Opacity, sourceRect, clientRect);
+                    context.DrawBitmap(bitmap, layer.Opacity, sourceRect, clientRect);
                 }
                 else
                 {
-                    context.DrawImage(bitmap, layer.OpacityMask, layer.OpacityMaskRect, sourceRect);
+                    context.DrawBitmap(bitmap, layer.OpacityMask, layer.OpacityMaskRect, sourceRect);
                 }
 
                 if (layer.GeometryClip != null)
@@ -485,7 +485,7 @@ namespace Avalonia.Rendering
             if (_overlay != null)
             {
                 var sourceRect = new Rect(0, 0, _overlay.Item.PixelSize.Width, _overlay.Item.PixelSize.Height);
-                context.DrawImage(_overlay, 0.5, sourceRect, clientRect);
+                context.DrawBitmap(_overlay, 0.5, sourceRect, clientRect);
             }
 
             if (DrawFps)
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/DeferredDrawingContextImpl.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/DeferredDrawingContextImpl.cs
index a169a629be..b362321745 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/DeferredDrawingContextImpl.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/DeferredDrawingContextImpl.cs
@@ -115,7 +115,7 @@ namespace Avalonia.Rendering.SceneGraph
         }
 
         /// <inheritdoc/>
-        public void DrawImage(IRef<IBitmapImpl> source, double opacity, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode)
+        public void DrawBitmap(IRef<IBitmapImpl> source, double opacity, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode)
         {
             var next = NextDrawAs<ImageNode>();
 
@@ -130,7 +130,7 @@ namespace Avalonia.Rendering.SceneGraph
         }
 
         /// <inheritdoc/>
-        public void DrawImage(IRef<IBitmapImpl> source, IBrush opacityMask, Rect opacityMaskRect, Rect sourceRect)
+        public void DrawBitmap(IRef<IBitmapImpl> source, IBrush opacityMask, Rect opacityMaskRect, Rect sourceRect)
         {
             // This method is currently only used to composite layers so shouldn't be called here.
             throw new NotSupportedException();
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/ImageNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/ImageNode.cs
index e1bdcaab3b..054f33c95d 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/ImageNode.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/ImageNode.cs
@@ -100,7 +100,7 @@ namespace Avalonia.Rendering.SceneGraph
         public override void Render(IDrawingContextImpl context)
         {
             context.Transform = Transform;
-            context.DrawImage(Source, Opacity, SourceRect, DestRect, BitmapInterpolationMode);
+            context.DrawBitmap(Source, Opacity, SourceRect, DestRect, BitmapInterpolationMode);
         }
 
         /// <inheritdoc/>
diff --git a/src/Avalonia.X11/X11IconLoader.cs b/src/Avalonia.X11/X11IconLoader.cs
index f0e75536d0..093f2b12c1 100644
--- a/src/Avalonia.X11/X11IconLoader.cs
+++ b/src/Avalonia.X11/X11IconLoader.cs
@@ -59,7 +59,7 @@ namespace Avalonia.X11
             }
             using(var rt = AvaloniaLocator.Current.GetService<IPlatformRenderInterface>().CreateRenderTarget(new[]{this}))
             using (var ctx = rt.CreateDrawingContext(null))
-                ctx.DrawImage(bitmap.PlatformImpl, 1, new Rect(bitmap.Size),
+                ctx.DrawBitmap(bitmap.PlatformImpl, 1, new Rect(bitmap.Size),
                     new Rect(0, 0, _width, _height));
             Data = new UIntPtr[_width * _height + 2];
             Data[0] = new UIntPtr((uint)_width);
diff --git a/src/Skia/Avalonia.Skia/DrawingContextImpl.cs b/src/Skia/Avalonia.Skia/DrawingContextImpl.cs
index d06cfa69a7..1c05f8ac9f 100644
--- a/src/Skia/Avalonia.Skia/DrawingContextImpl.cs
+++ b/src/Skia/Avalonia.Skia/DrawingContextImpl.cs
@@ -110,7 +110,7 @@ namespace Avalonia.Skia
         }
 
         /// <inheritdoc />
-        public void DrawImage(IRef<IBitmapImpl> source, double opacity, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode)
+        public void DrawBitmap(IRef<IBitmapImpl> source, double opacity, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode)
         {
             var drawableImage = (IDrawableBitmapImpl)source.Item;
             var s = sourceRect.ToSKRect();
@@ -146,10 +146,10 @@ namespace Avalonia.Skia
         }
 
         /// <inheritdoc />
-        public void DrawImage(IRef<IBitmapImpl> source, IBrush opacityMask, Rect opacityMaskRect, Rect destRect)
+        public void DrawBitmap(IRef<IBitmapImpl> source, IBrush opacityMask, Rect opacityMaskRect, Rect destRect)
         {
             PushOpacityMask(opacityMask, opacityMaskRect);
-            DrawImage(source, 1, new Rect(0, 0, source.Item.PixelSize.Width, source.Item.PixelSize.Height), destRect, BitmapInterpolationMode.Default);
+            DrawBitmap(source, 1, new Rect(0, 0, source.Item.PixelSize.Width, source.Item.PixelSize.Height), destRect, BitmapInterpolationMode.Default);
             PopOpacityMask();
         }
 
@@ -437,7 +437,7 @@ namespace Avalonia.Skia
                 context.Clear(Colors.Transparent);
                 context.PushClip(calc.IntermediateClip);
                 context.Transform = calc.IntermediateTransform;
-                context.DrawImage(
+                context.DrawBitmap(
                     RefCountable.CreateUnownedNotClonable(tileBrushImage),
                     1,
                     sourceRect,
diff --git a/src/Windows/Avalonia.Direct2D1/Media/DrawingContextImpl.cs b/src/Windows/Avalonia.Direct2D1/Media/DrawingContextImpl.cs
index aa13003643..81d869f3b8 100644
--- a/src/Windows/Avalonia.Direct2D1/Media/DrawingContextImpl.cs
+++ b/src/Windows/Avalonia.Direct2D1/Media/DrawingContextImpl.cs
@@ -109,7 +109,7 @@ namespace Avalonia.Direct2D1.Media
         /// <param name="sourceRect">The rect in the image to draw.</param>
         /// <param name="destRect">The rect in the output to draw to.</param>
         /// <param name="bitmapInterpolationMode">The bitmap interpolation mode.</param>
-        public void DrawImage(IRef<IBitmapImpl> source, double opacity, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode)
+        public void DrawBitmap(IRef<IBitmapImpl> source, double opacity, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode)
         {
             using (var d2d = ((BitmapImpl)source.Item).GetDirect2DBitmap(_deviceContext))
             {
@@ -149,7 +149,7 @@ namespace Avalonia.Direct2D1.Media
         /// <param name="opacityMask">The opacity mask to draw with.</param>
         /// <param name="opacityMaskRect">The destination rect for the opacity mask.</param>
         /// <param name="destRect">The rect in the output to draw to.</param>
-        public void DrawImage(IRef<IBitmapImpl> source, IBrush opacityMask, Rect opacityMaskRect, Rect destRect)
+        public void DrawBitmap(IRef<IBitmapImpl> source, IBrush opacityMask, Rect opacityMaskRect, Rect destRect)
         {
             using (var d2dSource = ((BitmapImpl)source.Item).GetDirect2DBitmap(_deviceContext))
             using (var sourceBrush = new BitmapBrush(_deviceContext, d2dSource.Value))
diff --git a/src/Windows/Avalonia.Direct2D1/Media/ImageBrushImpl.cs b/src/Windows/Avalonia.Direct2D1/Media/ImageBrushImpl.cs
index fbc6d21cb7..6632e2b3e7 100644
--- a/src/Windows/Avalonia.Direct2D1/Media/ImageBrushImpl.cs
+++ b/src/Windows/Avalonia.Direct2D1/Media/ImageBrushImpl.cs
@@ -107,7 +107,7 @@ namespace Avalonia.Direct2D1.Media
                 context.PushClip(calc.IntermediateClip);
                 context.Transform = calc.IntermediateTransform;
                 
-                context.DrawImage(RefCountable.CreateUnownedNotClonable(bitmap), 1, rect, rect, _bitmapInterpolationMode);
+                context.DrawBitmap(RefCountable.CreateUnownedNotClonable(bitmap), 1, rect, rect, _bitmapInterpolationMode);
                 context.PopClip();
             }
 
diff --git a/src/Windows/Avalonia.Direct2D1/Media/Imaging/D2DRenderTargetBitmapImpl.cs b/src/Windows/Avalonia.Direct2D1/Media/Imaging/D2DRenderTargetBitmapImpl.cs
index 8ec368c999..b96441e357 100644
--- a/src/Windows/Avalonia.Direct2D1/Media/Imaging/D2DRenderTargetBitmapImpl.cs
+++ b/src/Windows/Avalonia.Direct2D1/Media/Imaging/D2DRenderTargetBitmapImpl.cs
@@ -58,7 +58,7 @@ namespace Avalonia.Direct2D1.Media.Imaging
             {
                 using (var dc = wic.CreateDrawingContext(null))
                 {
-                    dc.DrawImage(
+                    dc.DrawBitmap(
                         RefCountable.CreateUnownedNotClonable(this),
                         1,
                         new Rect(PixelSize.ToSizeWithDpi(Dpi.X)),
diff --git a/tests/Avalonia.RenderTests/Media/BitmapTests.cs b/tests/Avalonia.RenderTests/Media/BitmapTests.cs
index 97e234a55b..7564d43070 100644
--- a/tests/Avalonia.RenderTests/Media/BitmapTests.cs
+++ b/tests/Avalonia.RenderTests/Media/BitmapTests.cs
@@ -94,7 +94,7 @@ namespace Avalonia.Direct2D1.RenderTests.Media
                     ctx.DrawRectangle(Brushes.Pink, null, new Rect(0, 20, 100, 10));
 
                     var rc = new Rect(0, 0, 60, 60);
-                    ctx.DrawImage(bmp.PlatformImpl, 1, rc, rc);
+                    ctx.DrawBitmap(bmp.PlatformImpl, 1, rc, rc);
                 }
                 rtb.Save(System.IO.Path.Combine(OutputPath, testName + ".out.png"));
             }
diff --git a/tests/Avalonia.Visuals.UnitTests/Rendering/DeferredRendererTests.cs b/tests/Avalonia.Visuals.UnitTests/Rendering/DeferredRendererTests.cs
index 2061caa320..ea192a1310 100644
--- a/tests/Avalonia.Visuals.UnitTests/Rendering/DeferredRendererTests.cs
+++ b/tests/Avalonia.Visuals.UnitTests/Rendering/DeferredRendererTests.cs
@@ -670,7 +670,7 @@ namespace Avalonia.Visuals.UnitTests.Rendering
             var context = Mock.Get(target.RenderTarget.CreateDrawingContext(null));
             var borderLayer = target.Layers[border].Bitmap;
 
-            context.Verify(x => x.DrawImage(borderLayer, 0.5, It.IsAny<Rect>(), It.IsAny<Rect>(), BitmapInterpolationMode.Default));
+            context.Verify(x => x.DrawBitmap(borderLayer, 0.5, It.IsAny<Rect>(), It.IsAny<Rect>(), BitmapInterpolationMode.Default));
         }
 
         [Fact]

From 6bd9ca8fa369b6713403b9078eb8cc1497436653 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 19 Dec 2019 17:35:59 +0100
Subject: [PATCH 16/46] Initial implementation of DrawingImage.

---
 src/Avalonia.Visuals/Media/Drawing.cs      |  6 +++--
 src/Avalonia.Visuals/Media/DrawingGroup.cs |  3 ++-
 src/Avalonia.Visuals/Media/DrawingImage.cs | 29 ++++++++++++++++++++++
 3 files changed, 35 insertions(+), 3 deletions(-)
 create mode 100644 src/Avalonia.Visuals/Media/DrawingImage.cs

diff --git a/src/Avalonia.Visuals/Media/Drawing.cs b/src/Avalonia.Visuals/Media/Drawing.cs
index a60c591edc..6bc808e407 100644
--- a/src/Avalonia.Visuals/Media/Drawing.cs
+++ b/src/Avalonia.Visuals/Media/Drawing.cs
@@ -1,4 +1,6 @@
-namespace Avalonia.Media
+using Avalonia.Platform;
+
+namespace Avalonia.Media
 {
     public abstract class Drawing : AvaloniaObject
     {
@@ -6,4 +8,4 @@
 
         public abstract Rect GetBounds();
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Visuals/Media/DrawingGroup.cs b/src/Avalonia.Visuals/Media/DrawingGroup.cs
index 744ff2af03..e581c8c553 100644
--- a/src/Avalonia.Visuals/Media/DrawingGroup.cs
+++ b/src/Avalonia.Visuals/Media/DrawingGroup.cs
@@ -1,5 +1,6 @@
 using Avalonia.Collections;
 using Avalonia.Metadata;
+using Avalonia.Platform;
 
 namespace Avalonia.Media
 {
@@ -55,4 +56,4 @@ namespace Avalonia.Media
             return rect;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Avalonia.Visuals/Media/DrawingImage.cs b/src/Avalonia.Visuals/Media/DrawingImage.cs
new file mode 100644
index 0000000000..594118d7de
--- /dev/null
+++ b/src/Avalonia.Visuals/Media/DrawingImage.cs
@@ -0,0 +1,29 @@
+using Avalonia.Platform;
+using Avalonia.Visuals.Media.Imaging;
+
+namespace Avalonia.Media
+{
+    public class DrawingImage : AvaloniaObject, IImage
+    {
+        public static readonly StyledProperty<Drawing> DrawingProperty =
+            AvaloniaProperty.Register<DrawingImage, Drawing>(nameof(Drawing));
+
+        public Drawing Drawing
+        {
+            get => GetValue(DrawingProperty);
+            set => SetValue(DrawingProperty, value);
+        }
+
+        public Size Size => Drawing?.GetBounds().Size ?? default;
+
+        public void Draw(
+            DrawingContext context,
+            double opacity,
+            Rect sourceRect,
+            Rect destRect,
+            BitmapInterpolationMode bitmapInterpolationMode)
+        {
+            Drawing?.Draw(context);
+        }
+    }
+}

From 11a714dbf796439101f13c0015cc91192d1689a6 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 20 Dec 2019 12:34:25 +0100
Subject: [PATCH 17/46] Use Size not PixelSize in ImageTests.

`Image` now bases the size of a bitmap on `IImage.Size`.
---
 tests/Avalonia.Controls.UnitTests/ImageTests.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/Avalonia.Controls.UnitTests/ImageTests.cs b/tests/Avalonia.Controls.UnitTests/ImageTests.cs
index 5102085fbf..d3c0e29eca 100644
--- a/tests/Avalonia.Controls.UnitTests/ImageTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ImageTests.cs
@@ -169,7 +169,7 @@ namespace Avalonia.Controls.UnitTests
 
         private IBitmap CreateBitmap(int width, int height)
         {
-            return Mock.Of<IBitmap>(x => x.PixelSize == new PixelSize(width, height));
+            return Mock.Of<IBitmap>(x => x.Size == new Size(width, height));
         }
     }
 }

From fd08fdc82060a09a7389d4130e194eba09c36d21 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 20 Dec 2019 12:34:54 +0100
Subject: [PATCH 18/46] Update ControlCatalog image page.

To display `DrawingImage`.
---
 samples/ControlCatalog/MainView.xaml          |  6 +-
 samples/ControlCatalog/Pages/ImagePage.xaml   | 85 ++++++++++---------
 .../ControlCatalog/Pages/ImagePage.xaml.cs    | 39 ++++-----
 src/Avalonia.Controls/Image.cs                | 15 ++--
 src/Avalonia.Visuals/Media/DrawingImage.cs    | 25 +++++-
 src/Avalonia.Visuals/Media/GeometryDrawing.cs |  5 +-
 .../AvaloniaXamlIlLanguage.cs                 |  2 +-
 7 files changed, 106 insertions(+), 71 deletions(-)

diff --git a/samples/ControlCatalog/MainView.xaml b/samples/ControlCatalog/MainView.xaml
index 874560a294..cbe2c62890 100644
--- a/samples/ControlCatalog/MainView.xaml
+++ b/samples/ControlCatalog/MainView.xaml
@@ -32,7 +32,11 @@
       <TabItem Header="DatePicker"><pages:DatePickerPage/></TabItem>
       <TabItem Header="Drag+Drop"><pages:DragAndDropPage/></TabItem>
       <TabItem Header="Expander"><pages:ExpanderPage/></TabItem>
-      <TabItem Header="Image"><pages:ImagePage/></TabItem>
+      <TabItem Header="Image"
+               ScrollViewer.VerticalScrollBarVisibility="Disabled"
+               ScrollViewer.HorizontalScrollBarVisibility="Disabled">
+        <pages:ImagePage/>
+      </TabItem>
       <TabItem Header="ItemsRepeater"
                ScrollViewer.VerticalScrollBarVisibility="Disabled"
                ScrollViewer.HorizontalScrollBarVisibility="Disabled">
diff --git a/samples/ControlCatalog/Pages/ImagePage.xaml b/samples/ControlCatalog/Pages/ImagePage.xaml
index b44fac27cb..9b8f8af765 100644
--- a/samples/ControlCatalog/Pages/ImagePage.xaml
+++ b/samples/ControlCatalog/Pages/ImagePage.xaml
@@ -1,45 +1,52 @@
 <UserControl xmlns="https://github.com/avaloniaui"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              x:Class="ControlCatalog.Pages.ImagePage">
-  <StackPanel Orientation="Vertical" Spacing="4">
-    <TextBlock Classes="h1">Image</TextBlock>
-    <TextBlock Classes="h2">Displays an image</TextBlock>
-
-    <StackPanel Orientation="Horizontal"
-                Margin="0,16,0,0"
-                HorizontalAlignment="Center"
-                Spacing="16">
-      <StackPanel Orientation="Vertical">
-        <TextBlock>No Stretch</TextBlock>
-        <Image Source="/Assets/delicate-arch-896885_640.jpg"
-               Width="100" Height="200"
-               Stretch="None"/>
-      </StackPanel>
-
-      <StackPanel Orientation="Vertical">
-        <TextBlock>Fill</TextBlock>
-        <Image Source="/Assets/delicate-arch-896885_640.jpg"
-               Width="100" Height="200"
-               Stretch="Fill"/>
-      </StackPanel>
+  <DockPanel>
+    <StackPanel DockPanel.Dock="Top" Orientation="Vertical" Spacing="4">
+      <TextBlock Classes="h1">Image</TextBlock>
+      <TextBlock Classes="h2">Displays an image</TextBlock>
+    </StackPanel>
 
-      <StackPanel Orientation="Vertical">
-        <TextBlock>Uniform</TextBlock>
-        <Image Source="/Assets/delicate-arch-896885_640.jpg"
-                Width="100" Height="200"
-                Stretch="Uniform"/>
-      </StackPanel>
+    <Grid ColumnDefinitions="*,*" RowDefinitions="Auto,*" Margin="64">
+      
+      <DockPanel Grid.Column="0" Grid.Row="1" Margin="16">
+        <TextBlock DockPanel.Dock="Top" Classes="h3" Margin="0 8">Bitmap</TextBlock>
+        <ComboBox Name="bitmapStretch" DockPanel.Dock="Top" SelectedIndex="2" SelectionChanged="BitmapStretchChanged">
+          <ComboBoxItem>None</ComboBoxItem>
+          <ComboBoxItem>Fill</ComboBoxItem>
+          <ComboBoxItem>Uniform</ComboBoxItem>
+          <ComboBoxItem>UniformToFill</ComboBoxItem>
+        </ComboBox>
+        <Image Name="bitmapImage"
+               Source="/Assets/delicate-arch-896885_640.jpg"/>
+      </DockPanel>
 
-      <StackPanel Orientation="Vertical">
-        <TextBlock>UniformToFill</TextBlock>
-        <Image Source="/Assets/delicate-arch-896885_640.jpg"
-               Width="100" Height="200"
-               Stretch="UniformToFill"/>
-      </StackPanel>
-    </StackPanel>
-    <StackPanel Orientation="Vertical">
-      <TextBlock>Window Icon as an Image</TextBlock>
-      <Image Name="Icon" Width="100" Height="200" Stretch="None" />
-    </StackPanel>
-  </StackPanel>
+      <DockPanel Grid.Column="1" Grid.Row="1" Margin="16">
+        <TextBlock DockPanel.Dock="Top" Classes="h3" Margin="0 8">Drawing</TextBlock>
+        <ComboBox Name="drawingStretch" DockPanel.Dock="Top" SelectedIndex="2" SelectionChanged="DrawingStretchChanged">
+          <ComboBoxItem>None</ComboBoxItem>
+          <ComboBoxItem>Fill</ComboBoxItem>
+          <ComboBoxItem>Uniform</ComboBoxItem>
+          <ComboBoxItem>UniformToFill</ComboBoxItem>
+        </ComboBox>
+        <Image Name="drawingImage">
+          <Image.Source>
+            <DrawingImage>
+              <GeometryDrawing Brush="Red">
+                <PathGeometry>
+                  <PathFigure StartPoint="0,0" IsClosed="True">
+                    <QuadraticBezierSegment Point1="50,0" Point2="50,-50" />
+                    <QuadraticBezierSegment Point1="100,-50" Point2="100,0" />
+                    <LineSegment Point="50,0" />
+                    <LineSegment Point="50,50" />
+                  </PathFigure>
+                </PathGeometry>
+              </GeometryDrawing>
+            </DrawingImage>
+          </Image.Source>
+        </Image>
+      </DockPanel>
+    </Grid>
+    
+  </DockPanel>
 </UserControl>
diff --git a/samples/ControlCatalog/Pages/ImagePage.xaml.cs b/samples/ControlCatalog/Pages/ImagePage.xaml.cs
index 792b25963e..bbe89d1dfd 100644
--- a/samples/ControlCatalog/Pages/ImagePage.xaml.cs
+++ b/samples/ControlCatalog/Pages/ImagePage.xaml.cs
@@ -1,40 +1,41 @@
-using System.IO;
-using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Markup.Xaml;
-using Avalonia.Media.Imaging;
+using Avalonia.Media;
 
 namespace ControlCatalog.Pages
 {
     public class ImagePage : UserControl
     {
-        private Image iconImage;
+        private readonly Image _bitmapImage;
+        private readonly Image _drawingImage;
+
         public ImagePage()
         {
-            this.InitializeComponent();
+            InitializeComponent();
+            _bitmapImage = this.FindControl<Image>("bitmapImage");
+            _drawingImage = this.FindControl<Image>("drawingImage");
         }
 
         private void InitializeComponent()
         {
             AvaloniaXamlLoader.Load(this);
-            iconImage = this.Get<Image>("Icon");
         }
 
-        protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
+        public void BitmapStretchChanged(object sender, SelectionChangedEventArgs e)
+        {
+            if (_bitmapImage != null)
+            {
+                var comboxBox = (ComboBox)sender;
+                _bitmapImage.Stretch = (Stretch)comboxBox.SelectedIndex;
+            }
+        }
+
+        public void DrawingStretchChanged(object sender, SelectionChangedEventArgs e)
         {
-            base.OnAttachedToVisualTree(e);
-            if (iconImage.Source == null)
+            if (_drawingImage != null)
             {
-                var windowRoot = e.Root as Window;
-                if (windowRoot != null)
-                {
-                    using (var stream = new MemoryStream())
-                    {
-                        windowRoot.Icon.Save(stream);
-                        stream.Seek(0, SeekOrigin.Begin);
-                        iconImage.Source = new Bitmap(stream);
-                    }
-                }
+                var comboxBox = (ComboBox)sender;
+                _drawingImage.Stretch = (Stretch)comboxBox.SelectedIndex;
             }
         }
     }
diff --git a/src/Avalonia.Controls/Image.cs b/src/Avalonia.Controls/Image.cs
index c2cdcb4e69..02014f4d31 100644
--- a/src/Avalonia.Controls/Image.cs
+++ b/src/Avalonia.Controls/Image.cs
@@ -14,8 +14,8 @@ namespace Avalonia.Controls
         /// <summary>
         /// Defines the <see cref="Source"/> property.
         /// </summary>
-        public static readonly StyledProperty<IBitmap> SourceProperty =
-            AvaloniaProperty.Register<Image, IBitmap>(nameof(Source));
+        public static readonly StyledProperty<IImage> SourceProperty =
+            AvaloniaProperty.Register<Image, IImage>(nameof(Source));
 
         /// <summary>
         /// Defines the <see cref="Stretch"/> property.
@@ -38,9 +38,9 @@ namespace Avalonia.Controls
         }
 
         /// <summary>
-        /// Gets or sets the bitmap image that will be displayed.
+        /// Gets or sets the image that will be displayed.
         /// </summary>
-        public IBitmap Source
+        public IImage Source
         {
             get { return GetValue(SourceProperty); }
             set { SetValue(SourceProperty, value); }
@@ -75,7 +75,7 @@ namespace Avalonia.Controls
             if (source != null)
             {
                 Rect viewPort = new Rect(Bounds.Size);
-                Size sourceSize = new Size(source.PixelSize.Width, source.PixelSize.Height);
+                Size sourceSize = source.Size;
                 Vector scale = Stretch.CalculateScaling(Bounds.Size, sourceSize, StretchDirection);
                 Size scaledSize = sourceSize * scale;
                 Rect destRect = viewPort
@@ -102,8 +102,7 @@ namespace Avalonia.Controls
 
             if (source != null)
             {
-                var sourceSize = new Size(source.PixelSize.Width, source.PixelSize.Height);
-                result = Stretch.CalculateSize(availableSize, sourceSize, StretchDirection);
+                result = Stretch.CalculateSize(availableSize, source.Size, StretchDirection);
             }
 
             return result;
@@ -116,7 +115,7 @@ namespace Avalonia.Controls
 
             if (source != null)
             {
-                var sourceSize = new Size(source.PixelSize.Width, source.PixelSize.Height);
+                var sourceSize = source.Size;
                 var result = Stretch.CalculateSize(finalSize, sourceSize);
                 return result;
             }
diff --git a/src/Avalonia.Visuals/Media/DrawingImage.cs b/src/Avalonia.Visuals/Media/DrawingImage.cs
index 594118d7de..9ddf88651c 100644
--- a/src/Avalonia.Visuals/Media/DrawingImage.cs
+++ b/src/Avalonia.Visuals/Media/DrawingImage.cs
@@ -1,4 +1,5 @@
-using Avalonia.Platform;
+using Avalonia.Metadata;
+using Avalonia.Platform;
 using Avalonia.Visuals.Media.Imaging;
 
 namespace Avalonia.Media
@@ -8,6 +9,7 @@ namespace Avalonia.Media
         public static readonly StyledProperty<Drawing> DrawingProperty =
             AvaloniaProperty.Register<DrawingImage, Drawing>(nameof(Drawing));
 
+        [Content]
         public Drawing Drawing
         {
             get => GetValue(DrawingProperty);
@@ -23,7 +25,26 @@ namespace Avalonia.Media
             Rect destRect,
             BitmapInterpolationMode bitmapInterpolationMode)
         {
-            Drawing?.Draw(context);
+            var drawing = Drawing;
+
+            if (drawing == null)
+            {
+                return;
+            }
+
+            var bounds = drawing.GetBounds();
+            var scale = Matrix.CreateScale(
+                destRect.Width / sourceRect.Width,
+                destRect.Height / sourceRect.Height);
+            var translate = Matrix.CreateTranslation(
+                -sourceRect.X + destRect.X - bounds.X,
+                -sourceRect.Y + destRect.Y - bounds.Y);
+
+            using (context.PushClip(destRect))
+            using (context.PushPreTransform(translate * scale))
+            {
+                Drawing?.Draw(context);
+            }
         }
     }
 }
diff --git a/src/Avalonia.Visuals/Media/GeometryDrawing.cs b/src/Avalonia.Visuals/Media/GeometryDrawing.cs
index 3dad10fb8f..4df3aa8ae2 100644
--- a/src/Avalonia.Visuals/Media/GeometryDrawing.cs
+++ b/src/Avalonia.Visuals/Media/GeometryDrawing.cs
@@ -1,10 +1,13 @@
-namespace Avalonia.Media
+using Avalonia.Metadata;
+
+namespace Avalonia.Media
 {
     public class GeometryDrawing : Drawing
     {
         public static readonly StyledProperty<Geometry> GeometryProperty =
             AvaloniaProperty.Register<GeometryDrawing, Geometry>(nameof(Geometry));
 
+        [Content]
         public Geometry Geometry
         {
             get => GetValue(GeometryProperty);
diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlLanguage.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlLanguage.cs
index 63c8b1c074..ebe4035ed6 100644
--- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlLanguage.cs
+++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlLanguage.cs
@@ -99,7 +99,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions
                 void Add(string type, string conv)
                     => AddType(typeSystem.GetType(type), typeSystem.GetType(conv));
                 
-                Add("Avalonia.Media.Imaging.IBitmap","Avalonia.Markup.Xaml.Converters.BitmapTypeConverter");
+                Add("Avalonia.Media.IImage","Avalonia.Markup.Xaml.Converters.BitmapTypeConverter");
                 var ilist = typeSystem.GetType("System.Collections.Generic.IList`1");
                 AddType(ilist.MakeGenericType(typeSystem.GetType("Avalonia.Point")),
                     typeSystem.GetType("Avalonia.Markup.Xaml.Converters.PointsListTypeConverter"));

From 44fa2152bd7dd6494fa8ae304cc28ca45283fe5a Mon Sep 17 00:00:00 2001
From: Andrey Kunchev <donandren@gmail.com>
Date: Fri, 20 Dec 2019 14:23:16 +0200
Subject: [PATCH 19/46] add failing test for #3376

---
 .../FontManagerImplTests.cs                    | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/tests/Avalonia.Skia.UnitTests/FontManagerImplTests.cs b/tests/Avalonia.Skia.UnitTests/FontManagerImplTests.cs
index 927f98b32b..fdd88dab0e 100644
--- a/tests/Avalonia.Skia.UnitTests/FontManagerImplTests.cs
+++ b/tests/Avalonia.Skia.UnitTests/FontManagerImplTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Reflection;
 using Avalonia.Media;
 using Avalonia.Platform;
@@ -29,6 +30,23 @@ namespace Avalonia.Skia.UnitTests
             Assert.Equal(SKTypeface.Default.FontSlant, skTypeface.FontSlant);
         }
 
+        [Fact]
+        public void Should_Create_Typeface_From_Fallback_Bold()
+        {
+            var fontManager = new FontManagerImpl();
+
+            //we need to have a valid font name different from the default one
+            string fontName = fontManager.GetInstalledFontFamilyNames().First();
+
+            var glyphTypeface = (GlyphTypefaceImpl)fontManager.CreateGlyphTypeface(
+                new Typeface(new FontFamily($"A, B, {fontName}"), FontWeight.Bold));
+
+            var skTypeface = glyphTypeface.Typeface;
+
+            Assert.Equal(fontName, skTypeface.FamilyName);
+            Assert.Equal(SKFontStyle.Bold.Weight, skTypeface.FontWeight);
+        }
+
         [Fact]
         public void Should_Create_Typeface_For_Unknown_Font()
         {

From dd864dd5c91dd7bd60aef78c262a4f264ccd07a5 Mon Sep 17 00:00:00 2001
From: Andrey Kunchev <donandren@gmail.com>
Date: Fri, 20 Dec 2019 14:23:40 +0200
Subject: [PATCH 20/46] add a test for same situation for direct2d

---
 .../Media/FontManagerImplTests.cs             | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/tests/Avalonia.Direct2D1.UnitTests/Media/FontManagerImplTests.cs b/tests/Avalonia.Direct2D1.UnitTests/Media/FontManagerImplTests.cs
index 82471915f4..3320bcebca 100644
--- a/tests/Avalonia.Direct2D1.UnitTests/Media/FontManagerImplTests.cs
+++ b/tests/Avalonia.Direct2D1.UnitTests/Media/FontManagerImplTests.cs
@@ -36,6 +36,30 @@ namespace Avalonia.Direct2D1.UnitTests.Media
             }
         }
 
+        [Fact]
+        public void Should_Create_Typeface_From_Fallback_Bold()
+        {
+            using (AvaloniaLocator.EnterScope())
+            {
+                Direct2D1Platform.Initialize();
+
+                var fontManager = new FontManagerImpl();
+
+                var defaultName = fontManager.GetDefaultFontFamilyName();
+
+                var glyphTypeface = (GlyphTypefaceImpl)fontManager.CreateGlyphTypeface(
+                    new Typeface(new FontFamily("A, B, Arial"), FontWeight.Bold));
+
+                var font = glyphTypeface.DWFont;
+
+                Assert.Equal("Arial", font.FontFamily.FamilyNames.GetString(0));
+
+                Assert.Equal(SharpDX.DirectWrite.FontWeight.Bold, font.Weight);
+
+                Assert.Equal(SharpDX.DirectWrite.FontStyle.Normal, font.Style);
+            }
+        }
+
         [Fact]
         public void Should_Create_Typeface_For_Unknown_Font()
         {

From c64cc71c6c68413e414c662e7d73d7fdfe4454d8 Mon Sep 17 00:00:00 2001
From: Andrey Kunchev <donandren@gmail.com>
Date: Fri, 20 Dec 2019 14:26:13 +0200
Subject: [PATCH 21/46] fix fontfallback for font with  some styles like
 bold/italic etc.

---
 src/Skia/Avalonia.Skia/FontManagerImpl.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/Skia/Avalonia.Skia/FontManagerImpl.cs b/src/Skia/Avalonia.Skia/FontManagerImpl.cs
index 727947e59d..60d6ecaabc 100644
--- a/src/Skia/Avalonia.Skia/FontManagerImpl.cs
+++ b/src/Skia/Avalonia.Skia/FontManagerImpl.cs
@@ -89,12 +89,15 @@ namespace Avalonia.Skia
 
             if (typeface.FontFamily.Key == null)
             {
+                var defaultName = SKTypeface.Default.FamilyName;
+
                 foreach (var familyName in typeface.FontFamily.FamilyNames)
                 {
                     skTypeface = SKTypeface.FromFamilyName(familyName, (SKFontStyleWeight)typeface.Weight,
                         SKFontStyleWidth.Normal, (SKFontStyleSlant)typeface.Style);
 
-                    if (skTypeface == SKTypeface.Default)
+                    if (!skTypeface.FamilyName.Equals(familyName, StringComparison.Ordinal) &&
+                        defaultName.Equals(skTypeface.FamilyName, StringComparison.Ordinal))
                     {
                         continue;
                     }

From dbe4301d36c827475f6bdbb9965ac305072f1015 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 20 Dec 2019 13:28:55 +0100
Subject: [PATCH 22/46] Sanitize image drawing API.

- Remove opacity parameter - should push an opacity instead
- Add a WPF-compatible overload of `DrawImage` to `DrawingContext`
---
 .../RenderDemo/Pages/RenderTargetBitmapPage.cs  |  2 +-
 src/Avalonia.Controls/Image.cs                  |  2 +-
 src/Avalonia.Controls/Remote/RemoteWidget.cs    |  2 +-
 src/Avalonia.Visuals/Media/DrawingContext.cs    | 17 ++++++++++++++---
 src/Avalonia.Visuals/Media/DrawingImage.cs      |  1 -
 src/Avalonia.Visuals/Media/IImage.cs            |  2 --
 src/Avalonia.Visuals/Media/Imaging/Bitmap.cs    |  3 +--
 7 files changed, 18 insertions(+), 11 deletions(-)

diff --git a/samples/RenderDemo/Pages/RenderTargetBitmapPage.cs b/samples/RenderDemo/Pages/RenderTargetBitmapPage.cs
index 3eb2276c48..f263786ab7 100644
--- a/samples/RenderDemo/Pages/RenderTargetBitmapPage.cs
+++ b/samples/RenderDemo/Pages/RenderTargetBitmapPage.cs
@@ -39,7 +39,7 @@ namespace RenderDemo.Pages
                 ctx.FillRectangle(Brushes.Fuchsia, new Rect(50, 50, 100, 100));
             }
 
-            context.DrawImage(_bitmap, 1, 
+            context.DrawImage(_bitmap,
                 new Rect(0, 0, 200, 200), 
                 new Rect(0, 0, 200, 200));
             Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
diff --git a/src/Avalonia.Controls/Image.cs b/src/Avalonia.Controls/Image.cs
index 02014f4d31..41b6e5449a 100644
--- a/src/Avalonia.Controls/Image.cs
+++ b/src/Avalonia.Controls/Image.cs
@@ -86,7 +86,7 @@ namespace Avalonia.Controls
 
                 var interpolationMode = RenderOptions.GetBitmapInterpolationMode(this);
 
-                context.DrawImage(source, 1, sourceRect, destRect, interpolationMode);
+                context.DrawImage(source, sourceRect, destRect, interpolationMode);
             }
         }
 
diff --git a/src/Avalonia.Controls/Remote/RemoteWidget.cs b/src/Avalonia.Controls/Remote/RemoteWidget.cs
index 539fe1ec4b..c7a1a24c25 100644
--- a/src/Avalonia.Controls/Remote/RemoteWidget.cs
+++ b/src/Avalonia.Controls/Remote/RemoteWidget.cs
@@ -83,7 +83,7 @@ namespace Avalonia.Controls.Remote
                         Marshal.Copy(_lastFrame.Data, y * _lastFrame.Stride,
                             new IntPtr(l.Address.ToInt64() + l.RowBytes * y), lineLen);
                 }
-                context.DrawImage(_bitmap, 1, new Rect(0, 0, _bitmap.PixelSize.Width, _bitmap.PixelSize.Height),
+                context.DrawImage(_bitmap, new Rect(0, 0, _bitmap.PixelSize.Width, _bitmap.PixelSize.Height),
                     new Rect(Bounds.Size));
             }
             base.Render(context);
diff --git a/src/Avalonia.Visuals/Media/DrawingContext.cs b/src/Avalonia.Visuals/Media/DrawingContext.cs
index 32fdf3b69a..4045b92c0c 100644
--- a/src/Avalonia.Visuals/Media/DrawingContext.cs
+++ b/src/Avalonia.Visuals/Media/DrawingContext.cs
@@ -77,15 +77,26 @@ namespace Avalonia.Media
         /// Draws an image.
         /// </summary>
         /// <param name="source">The image.</param>
-        /// <param name="opacity">The opacity to draw with.</param>
+        /// <param name="rect">The rect in the output to draw to.</param>
+        public void DrawImage(IImage source, Rect rect)
+        {
+            Contract.Requires<ArgumentNullException>(source != null);
+
+            DrawImage(source, new Rect(source.Size), rect);
+        }
+
+        /// <summary>
+        /// Draws an image.
+        /// </summary>
+        /// <param name="source">The image.</param>
         /// <param name="sourceRect">The rect in the image to draw.</param>
         /// <param name="destRect">The rect in the output to draw to.</param>
         /// <param name="bitmapInterpolationMode">The bitmap interpolation mode.</param>
-        public void DrawImage(IImage source, double opacity, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode = default)
+        public void DrawImage(IImage source, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode = default)
         {
             Contract.Requires<ArgumentNullException>(source != null);
 
-            source.Draw(this, opacity, sourceRect, destRect, bitmapInterpolationMode);
+            source.Draw(this, sourceRect, destRect, bitmapInterpolationMode);
         }
 
         /// <summary>
diff --git a/src/Avalonia.Visuals/Media/DrawingImage.cs b/src/Avalonia.Visuals/Media/DrawingImage.cs
index 9ddf88651c..9ce6ecd9e7 100644
--- a/src/Avalonia.Visuals/Media/DrawingImage.cs
+++ b/src/Avalonia.Visuals/Media/DrawingImage.cs
@@ -20,7 +20,6 @@ namespace Avalonia.Media
 
         public void Draw(
             DrawingContext context,
-            double opacity,
             Rect sourceRect,
             Rect destRect,
             BitmapInterpolationMode bitmapInterpolationMode)
diff --git a/src/Avalonia.Visuals/Media/IImage.cs b/src/Avalonia.Visuals/Media/IImage.cs
index 35ddf07f44..aff2a9ddf9 100644
--- a/src/Avalonia.Visuals/Media/IImage.cs
+++ b/src/Avalonia.Visuals/Media/IImage.cs
@@ -17,13 +17,11 @@ namespace Avalonia.Media
         /// Draws the image to a <see cref="DrawingContext"/>.
         /// </summary>
         /// <param name="context">The drawing context.</param>
-        /// <param name="opacity">The opacity to draw with.</param>
         /// <param name="sourceRect">The rect in the image to draw.</param>
         /// <param name="destRect">The rect in the output to draw to.</param>
         /// <param name="bitmapInterpolationMode">The bitmap interpolation mode.</param>
         void Draw(
             DrawingContext context,
-            double opacity,
             Rect sourceRect,
             Rect destRect,
             BitmapInterpolationMode bitmapInterpolationMode);
diff --git a/src/Avalonia.Visuals/Media/Imaging/Bitmap.cs b/src/Avalonia.Visuals/Media/Imaging/Bitmap.cs
index 8f154ad8e4..14ac4261dc 100644
--- a/src/Avalonia.Visuals/Media/Imaging/Bitmap.cs
+++ b/src/Avalonia.Visuals/Media/Imaging/Bitmap.cs
@@ -107,14 +107,13 @@ namespace Avalonia.Media.Imaging
         /// <inheritdoc/>
         void IImage.Draw(
             DrawingContext context,
-            double opacity,
             Rect sourceRect,
             Rect destRect,
             BitmapInterpolationMode bitmapInterpolationMode)
         {
             context.PlatformImpl.DrawBitmap(
                 PlatformImpl,
-                opacity,
+                1,
                 sourceRect,
                 destRect,
                 bitmapInterpolationMode);

From 37d00781cb29d4a26a30fd15e8670c0375a8473a Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 20 Dec 2019 13:33:00 +0100
Subject: [PATCH 23/46] Invalidate DrawingImage when Drawing changed.

And add some XML docs.
---
 src/Avalonia.Visuals/Media/DrawingImage.cs | 38 ++++++++++++++++++++--
 1 file changed, 35 insertions(+), 3 deletions(-)

diff --git a/src/Avalonia.Visuals/Media/DrawingImage.cs b/src/Avalonia.Visuals/Media/DrawingImage.cs
index 9ce6ecd9e7..d6ab004dd7 100644
--- a/src/Avalonia.Visuals/Media/DrawingImage.cs
+++ b/src/Avalonia.Visuals/Media/DrawingImage.cs
@@ -1,14 +1,27 @@
-using Avalonia.Metadata;
+using System;
+using Avalonia.Metadata;
 using Avalonia.Platform;
 using Avalonia.Visuals.Media.Imaging;
 
 namespace Avalonia.Media
 {
-    public class DrawingImage : AvaloniaObject, IImage
+    /// <summary>
+    /// An <see cref="IImage"/> that uses a <see cref="Drawing"/> for content.
+    /// </summary>
+    public class DrawingImage : AvaloniaObject, IImage, IAffectsRender
     {
+        /// <summary>
+        /// Defines the <see cref="Drawing"/> property.
+        /// </summary>
         public static readonly StyledProperty<Drawing> DrawingProperty =
             AvaloniaProperty.Register<DrawingImage, Drawing>(nameof(Drawing));
 
+        /// <inheritdoc/>
+        public event EventHandler Invalidated;
+
+        /// <summary>
+        /// Gets or sets the drawing content.
+        /// </summary>
         [Content]
         public Drawing Drawing
         {
@@ -16,9 +29,11 @@ namespace Avalonia.Media
             set => SetValue(DrawingProperty, value);
         }
 
+        /// <inheritdoc/>
         public Size Size => Drawing?.GetBounds().Size ?? default;
 
-        public void Draw(
+        /// <inheritdoc/>
+        void IImage.Draw(
             DrawingContext context,
             Rect sourceRect,
             Rect destRect,
@@ -45,5 +60,22 @@ namespace Avalonia.Media
                 Drawing?.Draw(context);
             }
         }
+
+        /// <inheritdoc/>
+        protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            base.OnPropertyChanged(e);
+
+            if (e.Property == DrawingProperty)
+            {
+                RaiseInvalidated(EventArgs.Empty);
+            }
+        }
+
+        /// <summary>
+        /// Raises the <see cref="Invalidated"/> event.
+        /// </summary>
+        /// <param name="e">The event args.</param>
+        protected void RaiseInvalidated(EventArgs e) => Invalidated?.Invoke(this, e);
     }
 }

From de31680253703dcfa66d66421d09b07b0f9d8ea6 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 20 Dec 2019 13:41:51 +0100
Subject: [PATCH 24/46] Make D2D backend match Skia.

Skia doesn't support getting DPI from loaded bitmaps and always returns 96. Do the same in D2D.
---
 .../Media/Imaging/D2DBitmapImpl.cs                 |  3 ++-
 .../Media/Imaging/WicBitmapImpl.cs                 | 14 ++++++--------
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/src/Windows/Avalonia.Direct2D1/Media/Imaging/D2DBitmapImpl.cs b/src/Windows/Avalonia.Direct2D1/Media/Imaging/D2DBitmapImpl.cs
index 1ee869ecb9..29c9280af6 100644
--- a/src/Windows/Avalonia.Direct2D1/Media/Imaging/D2DBitmapImpl.cs
+++ b/src/Windows/Avalonia.Direct2D1/Media/Imaging/D2DBitmapImpl.cs
@@ -30,7 +30,7 @@ namespace Avalonia.Direct2D1.Media
             _direct2DBitmap = d2DBitmap ?? throw new ArgumentNullException(nameof(d2DBitmap));
         }
 
-        public override Vector Dpi => _direct2DBitmap.DotsPerInch.ToAvaloniaVector();
+        public override Vector Dpi => new Vector(96, 96);
         public override PixelSize PixelSize => _direct2DBitmap.PixelSize.ToAvalonia();
 
         public override void Dispose()
@@ -58,3 +58,4 @@ namespace Avalonia.Direct2D1.Media
         }
     }
 }
+;
diff --git a/src/Windows/Avalonia.Direct2D1/Media/Imaging/WicBitmapImpl.cs b/src/Windows/Avalonia.Direct2D1/Media/Imaging/WicBitmapImpl.cs
index 176c3e0e23..4e0853c20c 100644
--- a/src/Windows/Avalonia.Direct2D1/Media/Imaging/WicBitmapImpl.cs
+++ b/src/Windows/Avalonia.Direct2D1/Media/Imaging/WicBitmapImpl.cs
@@ -26,6 +26,7 @@ namespace Avalonia.Direct2D1.Media
             using (BitmapDecoder decoder = new BitmapDecoder(Direct2D1Platform.ImagingFactory, fileName, DecodeOptions.CacheOnDemand))
             {
                 WicImpl = new Bitmap(Direct2D1Platform.ImagingFactory, decoder.GetFrame(0), BitmapCreateCacheOption.CacheOnDemand);
+                Dpi = new Vector(96, 96);
             }
         }
 
@@ -39,6 +40,7 @@ namespace Avalonia.Direct2D1.Media
             _decoder = new BitmapDecoder(Direct2D1Platform.ImagingFactory, stream, DecodeOptions.CacheOnLoad);
 
             WicImpl = new Bitmap(Direct2D1Platform.ImagingFactory, _decoder.GetFrame(0), BitmapCreateCacheOption.CacheOnLoad);
+            Dpi = new Vector(96, 96);
         }
 
         /// <summary>
@@ -62,6 +64,7 @@ namespace Avalonia.Direct2D1.Media
                 pixelFormat.Value.ToWic(),
                 BitmapCreateCacheOption.CacheOnLoad);
             WicImpl.SetResolution(dpi.X, dpi.Y);
+            Dpi = dpi;
         }
 
         public WicBitmapImpl(APixelFormat format, IntPtr data, PixelSize size, Vector dpi, int stride)
@@ -70,6 +73,8 @@ namespace Avalonia.Direct2D1.Media
             WicImpl.SetResolution(dpi.X, dpi.Y);
 
             PixelFormat = format;
+            Dpi = dpi;
+
             using (var l = WicImpl.Lock(BitmapLockFlags.Write))
             {
                 for (var row = 0; row < size.Height; row++)
@@ -82,14 +87,7 @@ namespace Avalonia.Direct2D1.Media
             }
         }
 
-        public override Vector Dpi
-        {
-            get
-            {
-                WicImpl.GetResolution(out double x, out double y);
-                return new Vector(x, y);
-            }
-        }
+        public override Vector Dpi { get; }
 
         public override PixelSize PixelSize => WicImpl.Size.ToAvalonia();
 

From 580697b25db7da2f1d251f666101287f4910fb30 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 20 Dec 2019 14:08:39 +0100
Subject: [PATCH 25/46] Make DrawingPresenter obsolete.

---
 src/Avalonia.Controls/DrawingPresenter.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/DrawingPresenter.cs b/src/Avalonia.Controls/DrawingPresenter.cs
index b30a8668fd..ee27aa7ec1 100644
--- a/src/Avalonia.Controls/DrawingPresenter.cs
+++ b/src/Avalonia.Controls/DrawingPresenter.cs
@@ -1,9 +1,11 @@
-using Avalonia.Controls.Shapes;
+using System;
+using Avalonia.Controls.Shapes;
 using Avalonia.Media;
 using Avalonia.Metadata;
 
 namespace Avalonia.Controls
 {
+    [Obsolete("Use Image control with DrawingImage source")]
     public class DrawingPresenter : Control
     {
         static DrawingPresenter()

From 11b1ec2ded6842ed4146d271abebba1bea986c3e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Pedro?= <jpedrolmail@gmail.com>
Date: Mon, 23 Dec 2019 23:45:02 +0000
Subject: [PATCH 26/46] Fixed PlatformHotkeyConfiguration obsolete API usage.

---
 src/Avalonia.Controls/TextBox.cs                   |  4 ++--
 .../Platform/PlatformHotkeyConfiguration.cs        | 14 +++++++-------
 src/Avalonia.Native/AvaloniaNativePlatform.cs      |  2 +-
 src/Avalonia.X11/X11Platform.cs                    |  2 +-
 4 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/Avalonia.Controls/TextBox.cs b/src/Avalonia.Controls/TextBox.cs
index c3eec851b9..fbac2e02ec 100644
--- a/src/Avalonia.Controls/TextBox.cs
+++ b/src/Avalonia.Controls/TextBox.cs
@@ -403,12 +403,12 @@ namespace Avalonia.Controls
             bool movement = false;
             bool selection = false;
             bool handled = false;
-            var modifiers = e.Modifiers;
+            var modifiers = e.KeyModifiers;
 
             var keymap = AvaloniaLocator.Current.GetService<PlatformHotkeyConfiguration>();
 
             bool Match(List<KeyGesture> gestures) => gestures.Any(g => g.Matches(e));
-            bool DetectSelection() => e.Modifiers.HasFlag(keymap.SelectionModifiers);
+            bool DetectSelection() => e.KeyModifiers.HasFlag(keymap.SelectionModifiers);
 
             if (Match(keymap.SelectAll))
             {
diff --git a/src/Avalonia.Input/Platform/PlatformHotkeyConfiguration.cs b/src/Avalonia.Input/Platform/PlatformHotkeyConfiguration.cs
index a758a328be..053f894755 100644
--- a/src/Avalonia.Input/Platform/PlatformHotkeyConfiguration.cs
+++ b/src/Avalonia.Input/Platform/PlatformHotkeyConfiguration.cs
@@ -4,14 +4,14 @@ namespace Avalonia.Input.Platform
 {
     public class PlatformHotkeyConfiguration
     {
-        public PlatformHotkeyConfiguration() : this(InputModifiers.Control)
+        public PlatformHotkeyConfiguration() : this(KeyModifiers.Control)
         {
             
         }
         
-        public PlatformHotkeyConfiguration(InputModifiers commandModifiers,
-            InputModifiers selectionModifiers = InputModifiers.Shift,
-            InputModifiers wholeWordTextActionModifiers = InputModifiers.Control)
+        public PlatformHotkeyConfiguration(KeyModifiers commandModifiers,
+            KeyModifiers selectionModifiers = KeyModifiers.Shift,
+            KeyModifiers wholeWordTextActionModifiers = KeyModifiers.Control)
         {
             CommandModifiers = commandModifiers;
             SelectionModifiers = selectionModifiers;
@@ -75,9 +75,9 @@ namespace Avalonia.Input.Platform
             };
         }
         
-        public InputModifiers CommandModifiers { get; set; }
-        public InputModifiers WholeWordTextActionModifiers { get; set; }
-        public InputModifiers SelectionModifiers { get; set; }
+        public KeyModifiers CommandModifiers { get; set; }
+        public KeyModifiers WholeWordTextActionModifiers { get; set; }
+        public KeyModifiers SelectionModifiers { get; set; }
         public List<KeyGesture> Copy { get; set; }
         public List<KeyGesture> Cut { get; set; }
         public List<KeyGesture> Paste { get; set; }
diff --git a/src/Avalonia.Native/AvaloniaNativePlatform.cs b/src/Avalonia.Native/AvaloniaNativePlatform.cs
index 571475c7ea..756619fa9f 100644
--- a/src/Avalonia.Native/AvaloniaNativePlatform.cs
+++ b/src/Avalonia.Native/AvaloniaNativePlatform.cs
@@ -101,7 +101,7 @@ namespace Avalonia.Native
                 .Bind<IRenderTimer>().ToConstant(new DefaultRenderTimer(60))
                 .Bind<ISystemDialogImpl>().ToConstant(new SystemDialogs(_factory.CreateSystemDialogs()))
                 .Bind<IWindowingPlatformGlFeature>().ToConstant(new GlPlatformFeature(_factory.ObtainGlFeature()))
-                .Bind<PlatformHotkeyConfiguration>().ToConstant(new PlatformHotkeyConfiguration(InputModifiers.Windows))
+                .Bind<PlatformHotkeyConfiguration>().ToConstant(new PlatformHotkeyConfiguration(KeyModifiers.Meta))
                 .Bind<IMountedVolumeInfoProvider>().ToConstant(new MacOSMountedVolumeInfoProvider());
         }
 
diff --git a/src/Avalonia.X11/X11Platform.cs b/src/Avalonia.X11/X11Platform.cs
index 6ba562bb69..8b531bd9c5 100644
--- a/src/Avalonia.X11/X11Platform.cs
+++ b/src/Avalonia.X11/X11Platform.cs
@@ -44,7 +44,7 @@ namespace Avalonia.X11
                 .Bind<IPlatformThreadingInterface>().ToConstant(new X11PlatformThreading(this))
                 .Bind<IRenderTimer>().ToConstant(new DefaultRenderTimer(60))
                 .Bind<IRenderLoop>().ToConstant(new RenderLoop())
-                .Bind<PlatformHotkeyConfiguration>().ToConstant(new PlatformHotkeyConfiguration(InputModifiers.Control))
+                .Bind<PlatformHotkeyConfiguration>().ToConstant(new PlatformHotkeyConfiguration(KeyModifiers.Control))
                 .Bind<IKeyboardDevice>().ToFunc(() => KeyboardDevice)
                 .Bind<IStandardCursorFactory>().ToConstant(new X11CursorFactory(Display))
                 .Bind<IClipboard>().ToConstant(new X11Clipboard(this))

From d50f33e91225d0e5f42eca0738de1cfeec502d05 Mon Sep 17 00:00:00 2001
From: Yahia Chiheb <chihebyahia@gmail.com>
Date: Mon, 30 Dec 2019 02:25:32 +0100
Subject: [PATCH 27/46] Fix typo

---
 src/Avalonia.Animation/IterationCount.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Avalonia.Animation/IterationCount.cs b/src/Avalonia.Animation/IterationCount.cs
index e9cd0686d8..9f57455639 100644
--- a/src/Avalonia.Animation/IterationCount.cs
+++ b/src/Avalonia.Animation/IterationCount.cs
@@ -63,7 +63,7 @@ namespace Avalonia.Animation
         public IterationType RepeatType => _type;
 
         /// <summary>
-        /// Gets a value that indicates whether the <see cref="IterationCount"/> is set to loop.
+        /// Gets a value that indicates whether the <see cref="IterationCount"/> is set to Infinite.
         /// </summary>
         public bool IsInfinite => _type == IterationType.Infinite;
 

From 7db73dfa95e2ee227a1d9404d29f8e407a94affe Mon Sep 17 00:00:00 2001
From: Yahia Chiheb <chihebyahia@gmail.com>
Date: Mon, 30 Dec 2019 02:32:28 +0100
Subject: [PATCH 28/46] Remove duplicate link (mentioned below)

---
 readme.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/readme.md b/readme.md
index 512b35a454..97c6509362 100644
--- a/readme.md
+++ b/readme.md
@@ -22,7 +22,7 @@ Avalonia [Visual Studio Extension](https://marketplace.visualstudio.com/items?it
 
 For those without Visual Studio, a starter guide for .NET Core CLI can be found [here](http://avaloniaui.net/docs/quickstart/create-new-project#net-core).
 
-Avalonia is delivered via <b>NuGet</b> package manager. You can find the packages here: ([stable(ish)](https://www.nuget.org/packages/Avalonia/), [nightly](https://github.com/AvaloniaUI/Avalonia/wiki/Using-nightly-build-feed))
+Avalonia is delivered via <b>NuGet</b> package manager. You can find the packages here: [stable(ish)](https://www.nuget.org/packages/Avalonia/)
 
 Use these commands in the Package Manager console to install Avalonia manually:
 ```

From cab67d680d0e4f568038e2401a8e012eb558dee8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Josua=20J=C3=A4ger?= <jaeger.josua@gmail.com>
Date: Sun, 5 Jan 2020 17:54:38 +0100
Subject: [PATCH 29/46] Delete avalonia-rename.ps1

Looks like the script is not needed anymore. I was initially searching for a script to build all Nuget Packages. Removing scripts that are no longer needed / up to date seems like a good idea.
---
 scripts/avalonia-rename.ps1 | 64 -------------------------------------
 1 file changed, 64 deletions(-)
 delete mode 100644 scripts/avalonia-rename.ps1

diff --git a/scripts/avalonia-rename.ps1 b/scripts/avalonia-rename.ps1
deleted file mode 100644
index c77dffb55d..0000000000
--- a/scripts/avalonia-rename.ps1
+++ /dev/null
@@ -1,64 +0,0 @@
-function Get-NewDirectoryName {
-    param ([System.IO.DirectoryInfo]$item)
-
-    $name = $item.Name.Replace("perspex", "avalonia")
-    $name = $name.Replace("Perspex", "Avalonia")
-    Join-Path $item.Parent.FullName $name
-}
-
-function Get-NewFileName {
-    param ([System.IO.FileInfo]$item)
-
-    $name = $item.Name.Replace("perspex", "avalonia")
-    $name = $name.Replace("Perspex", "Avalonia")
-    Join-Path $item.DirectoryName $name
-}
-
-function Rename-Contents {
-    param ([System.IO.FileInfo] $file)
-
-    $extensions = @(".cs",".xaml",".csproj",".sln",".md",".json",".yml",".partial",".ps1",".nuspec",".htm",".html",".gitmodules".".xml",".plist",".targets",".projitems",".shproj",".xib")
-
-    if ($extensions.Contains($file.Extension)) {
-        $text = [IO.File]::ReadAllText($file.FullName)
-        $text = $text.Replace("github.com/perspex", "github.com/avaloniaui")
-        $text = $text.Replace("github.com/Perspex", "github.com/AvaloniaUI")
-        $text = $text.Replace("perspex", "avalonia")
-        $text = $text.Replace("Perspex", "Avalonia")
-        $text = $text.Replace("PERSPEX", "AVALONIA")
-        [IO.File]::WriteAllText($file.FullName, $text)
-    }
-}
-
-function Process-Files {
-    param ([System.IO.DirectoryInfo] $item)
-
-    $dirs = Get-ChildItem -Path $item.FullName -Directory
-    $files = Get-ChildItem -Path $item.FullName -File
-
-    foreach ($dir in $dirs) {
-        Process-Files $dir.FullName
-    }
-
-    foreach ($file in $files) {
-        Rename-Contents $file
-
-        $renamed = Get-NewFileName $file
-
-        if ($file.FullName -ne $renamed) {
-            Write-Host git mv $file.FullName $renamed
-            & git mv $file.FullName $renamed
-        }
-    }
-
-    $renamed = Get-NewDirectoryName $item
-
-    if ($item.FullName -ne $renamed) {
-        Write-Host git mv $item.FullName $renamed
-        & git mv $item.FullName $renamed
-    }
-}
-
-& git submodule deinit .
-& git clean -xdf
-Process-Files .

From 33382159469c1bc620cbe43c971c1b3c06a418c7 Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Mon, 6 Jan 2020 10:01:06 -0300
Subject: [PATCH 30/46] fixes the black window corners on OSX.

---
 native/Avalonia.Native/src/OSX/window.mm | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/native/Avalonia.Native/src/OSX/window.mm b/native/Avalonia.Native/src/OSX/window.mm
index 908b9e1022..3acc5e365b 100644
--- a/native/Avalonia.Native/src/OSX/window.mm
+++ b/native/Avalonia.Native/src/OSX/window.mm
@@ -1283,6 +1283,9 @@ NSArray* AllLoopModes = [NSArray arrayWithObjects: NSDefaultRunLoopMode, NSEvent
     _closed = false;
     
     _lastScaling = [self backingScaleFactor];
+    [self setOpaque:NO];
+    [self setBackgroundColor: [NSColor clearColor]];
+    [self invalidateShadow];
     return self;
 }
 

From 4cca4f0e4cbec66b90b16a4e22681fd814a5fb7a Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 9 Jan 2020 08:35:28 +0100
Subject: [PATCH 31/46] update to repeater to allow passing in uielements in
 itemssource

* minor update to repeater to allow passing in uielements in itemssource

* minor fixes

Ported from https://github.com/microsoft/microsoft-ui-xaml/commit/95d5ff00768030e52c3a2b56cde99c36ff694168
---
 src/Avalonia.Controls/Repeater/ViewManager.cs | 43 +++++++++++++------
 1 file changed, 29 insertions(+), 14 deletions(-)

diff --git a/src/Avalonia.Controls/Repeater/ViewManager.cs b/src/Avalonia.Controls/Repeater/ViewManager.cs
index 51c14d47d6..e4fc1158ef 100644
--- a/src/Avalonia.Controls/Repeater/ViewManager.cs
+++ b/src/Avalonia.Controls/Repeater/ViewManager.cs
@@ -109,11 +109,10 @@ namespace Avalonia.Controls
 
         public void ClearElementToElementFactory(IControl element)
         {
-            var virtInfo = ItemsRepeater.GetVirtualizationInfo(element);
-            var clearedIndex = virtInfo.Index;
             _owner.OnElementClearing(element);
-            _owner.ItemTemplateShim.RecycleElement(_owner, element);
+            _owner.ItemTemplateShim?.RecycleElement(_owner, element);
 
+            var virtInfo = ItemsRepeater.GetVirtualizationInfo(element);
             virtInfo.MoveOwnershipToElementFactory();
 
             if (_lastFocusedElement == element)
@@ -121,9 +120,8 @@ namespace Avalonia.Controls
                 // Focused element is going away. Remove the tracked last focused element
                 // and pick a reasonable next focus if we can find one within the layout 
                 // realized elements.
-                MoveFocusFromClearedIndex(clearedIndex);
+                MoveFocusFromClearedIndex(virtInfo.Index);
             }
-
         }
 
         private void MoveFocusFromClearedIndex(int clearedIndex)
@@ -518,18 +516,32 @@ namespace Avalonia.Controls
         private IControl GetElementFromElementFactory(int index)
         {
             // The view generator is the provider of last resort.
-
+            var data = _owner.ItemsSourceView.GetAt(index);
             var itemTemplateFactory = _owner.ItemTemplateShim;
+            IControl element = null;
+            var itemsSourceContainsElements = false;
+
             if (itemTemplateFactory == null)
             {
-                // If no ItemTemplate was provided, use a default 
-                var factory = FuncDataTemplate.Default;
-                _owner.ItemTemplate = factory;
-                itemTemplateFactory = _owner.ItemTemplateShim;
+                element = data as IControl;
+
+                // No item template provided and ItemsSource contains objects derived from UIElement.
+                // In this case, just use the data directly as elements.
+                itemsSourceContainsElements = element != null;
             }
 
-            var data = _owner.ItemsSourceView.GetAt(index);
-            var element = itemTemplateFactory.GetElement(_owner, data);
+            if (element == null)
+            {
+                if (itemTemplateFactory == null)
+                {
+                    // If no ItemTemplate was provided, use a default 
+                    var factory = FuncDataTemplate.Default;
+                    _owner.ItemTemplate = factory;
+                    itemTemplateFactory = _owner.ItemTemplateShim;
+                }
+
+                element = itemTemplateFactory.GetElement(_owner, data);
+            }
 
             var virtInfo = ItemsRepeater.TryGetVirtualizationInfo(element);
             if (virtInfo == null)
@@ -537,8 +549,11 @@ namespace Avalonia.Controls
                 virtInfo = ItemsRepeater.CreateAndInitializeVirtualizationInfo(element);
             }
 
-            // Prepare the element
-            element.DataContext = data;
+            if (!itemsSourceContainsElements)
+            {
+                // Prepare the element
+                element.DataContext = data;
+            }
 
             virtInfo.MoveOwnershipToLayoutFromElementFactory(
                 index,

From 36fdb8e534f3a43a07a8380d3acb34189e94412e Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 9 Jan 2020 09:24:28 +0100
Subject: [PATCH 32/46] Add a MaximumRowsOrColumns to Uniformgridlayout

* Add a MaximumRowsOrColumns property to UniformGridLayout

* Fix nit

* Fix bugs

Ported from https://github.com/microsoft/microsoft-ui-xaml/commit/6bd03c98f770fed69312ed5efb6cc06b428fa758?w=1
---
 src/Avalonia.Layout/FlowLayoutAlgorithm.cs    | 14 +++---
 src/Avalonia.Layout/StackLayout.cs            |  1 +
 src/Avalonia.Layout/UniformGridLayout.cs      | 49 +++++++++++++++----
 src/Avalonia.Layout/UniformGridLayoutState.cs | 34 ++++++++++---
 4 files changed, 75 insertions(+), 23 deletions(-)

diff --git a/src/Avalonia.Layout/FlowLayoutAlgorithm.cs b/src/Avalonia.Layout/FlowLayoutAlgorithm.cs
index 615ce725bd..7343f4a6e9 100644
--- a/src/Avalonia.Layout/FlowLayoutAlgorithm.cs
+++ b/src/Avalonia.Layout/FlowLayoutAlgorithm.cs
@@ -72,6 +72,7 @@ namespace Avalonia.Layout
             bool isWrapping,
             double minItemSpacing,
             double lineSpacing,
+            int maxItemsPerLine,
             ScrollOrientation orientation,
             string layoutId)
         {
@@ -94,14 +95,14 @@ namespace Avalonia.Layout
             _elementManager.OnBeginMeasure(orientation);
 
             int anchorIndex = GetAnchorIndex(availableSize, isWrapping, minItemSpacing, layoutId);
-            Generate(GenerateDirection.Forward, anchorIndex, availableSize, minItemSpacing, lineSpacing, layoutId);
-            Generate(GenerateDirection.Backward, anchorIndex, availableSize, minItemSpacing, lineSpacing, layoutId);
+            Generate(GenerateDirection.Forward, anchorIndex, availableSize, minItemSpacing, lineSpacing, maxItemsPerLine, layoutId);
+            Generate(GenerateDirection.Backward, anchorIndex, availableSize, minItemSpacing, lineSpacing, maxItemsPerLine, layoutId);
             if (isWrapping && IsReflowRequired())
             {
                 var firstElementBounds = _elementManager.GetLayoutBoundsForRealizedIndex(0);
                 _orientation.SetMinorStart(ref firstElementBounds, 0);
                 _elementManager.SetLayoutBoundsForRealizedIndex(0, firstElementBounds);
-                Generate(GenerateDirection.Forward, 0 /*anchorIndex*/, availableSize, minItemSpacing, lineSpacing, layoutId);
+                Generate(GenerateDirection.Forward, 0 /*anchorIndex*/, availableSize, minItemSpacing, lineSpacing, maxItemsPerLine, layoutId);
             }
 
             RaiseLineArranged();
@@ -270,6 +271,7 @@ namespace Avalonia.Layout
             Size availableSize,
             double minItemSpacing,
             double lineSpacing,
+            int maxItemsPerLine,
             string layoutId)
         {
             if (anchorIndex != -1)
@@ -280,7 +282,7 @@ namespace Avalonia.Layout
                 var anchorBounds = _elementManager.GetLayoutBoundsForDataIndex(anchorIndex);
                 var lineOffset = _orientation.MajorStart(anchorBounds);
                 var lineMajorSize = _orientation.MajorSize(anchorBounds);
-                int countInLine = 1;
+                var countInLine = 1;
                 int count = 0;
                 bool lineNeedsReposition = false;
 
@@ -301,7 +303,7 @@ namespace Avalonia.Layout
                     if (direction == GenerateDirection.Forward)
                     {
                         double remainingSpace = _orientation.Minor(availableSize) - (_orientation.MinorStart(previousElementBounds) + _orientation.MinorSize(previousElementBounds) + minItemSpacing + _orientation.Minor(desiredSize));
-                        if (_algorithmCallbacks.Algorithm_ShouldBreakLine(currentIndex, remainingSpace))
+                        if (countInLine >= maxItemsPerLine || _algorithmCallbacks.Algorithm_ShouldBreakLine(currentIndex, remainingSpace))
                         {
                             // No more space in this row. wrap to next row.
                             _orientation.SetMinorStart(ref currentBounds, 0);
@@ -339,7 +341,7 @@ namespace Avalonia.Layout
                     {
                         // Backward 
                         double remainingSpace = _orientation.MinorStart(previousElementBounds) - (_orientation.Minor(desiredSize) + minItemSpacing);
-                        if (_algorithmCallbacks.Algorithm_ShouldBreakLine(currentIndex, remainingSpace))
+                        if (countInLine >= maxItemsPerLine || _algorithmCallbacks.Algorithm_ShouldBreakLine(currentIndex, remainingSpace))
                         {
                             // Does not fit, wrap to the previous row
                             var availableSizeMinor = _orientation.Minor(availableSize);
diff --git a/src/Avalonia.Layout/StackLayout.cs b/src/Avalonia.Layout/StackLayout.cs
index e9735b9b31..a3fe80fab7 100644
--- a/src/Avalonia.Layout/StackLayout.cs
+++ b/src/Avalonia.Layout/StackLayout.cs
@@ -267,6 +267,7 @@ namespace Avalonia.Layout
                 false,
                 0,
                 Spacing,
+                int.MaxValue,
                 _orientation.ScrollOrientation,
                 LayoutId);
 
diff --git a/src/Avalonia.Layout/UniformGridLayout.cs b/src/Avalonia.Layout/UniformGridLayout.cs
index edc2042922..16d21508a9 100644
--- a/src/Avalonia.Layout/UniformGridLayout.cs
+++ b/src/Avalonia.Layout/UniformGridLayout.cs
@@ -110,6 +110,12 @@ namespace Avalonia.Layout
         public static readonly StyledProperty<double> MinRowSpacingProperty =
             AvaloniaProperty.Register<UniformGridLayout, double>(nameof(MinRowSpacing));
 
+        /// <summary>
+        /// Defines the <see cref="MaximumRowsOrColumnsProperty"/> property.
+        /// </summary>
+        public static readonly StyledProperty<int> MaximumRowsOrColumnsProperty =
+            AvaloniaProperty.Register<UniformGridLayout, int>(nameof(MinItemWidth));
+
         /// <summary>
         /// Defines the <see cref="Orientation"/> property.
         /// </summary>
@@ -123,6 +129,7 @@ namespace Avalonia.Layout
         private double _minColumnSpacing;
         private UniformGridLayoutItemsJustification _itemsJustification;
         private UniformGridLayoutItemsStretch _itemsStretch;
+        private int _maximumRowsOrColumns = int.MaxValue;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="UniformGridLayout"/> class.
@@ -219,6 +226,15 @@ namespace Avalonia.Layout
             set => SetValue(MinRowSpacingProperty, value);
         }
 
+        /// <summary>
+        /// Gets or sets the maximum row or column count.
+        /// </summary>
+        public int MaximumRowsOrColumns
+        {
+            get => GetValue(MaximumRowsOrColumnsProperty);
+            set => SetValue(MaximumRowsOrColumnsProperty, value);
+        }
+
         /// <summary>
         /// Gets or sets the axis along which items are laid out.
         /// </summary>
@@ -269,15 +285,17 @@ namespace Avalonia.Layout
             {
                 var gridState = (UniformGridLayoutState)context.LayoutState;
                 var lastExtent = gridState.FlowAlgorithm.LastExtent;
-                int itemsPerLine = Math.Max(1, (int)(_orientation.Minor(availableSize) / GetMinorSizeWithSpacing(context)));
-                double majorSize = (itemsCount / itemsPerLine) * GetMajorSizeWithSpacing(context);
-                double realizationWindowStartWithinExtent = _orientation.MajorStart(realizationRect) - _orientation.MajorStart(lastExtent);
+                var itemsPerLine = Math.Min( // note use of unsigned ints
+                    Math.Max(1u, (uint)(_orientation.Minor(availableSize) / GetMinorSizeWithSpacing(context))),
+                    Math.Max(1u, (uint)_maximumRowsOrColumns));
+                var majorSize = (itemsCount / itemsPerLine) * GetMajorSizeWithSpacing(context);
+                var realizationWindowStartWithinExtent = _orientation.MajorStart(realizationRect) - _orientation.MajorStart(lastExtent);
                 if ((realizationWindowStartWithinExtent + _orientation.MajorSize(realizationRect)) >= 0 && realizationWindowStartWithinExtent <= majorSize)
                 {
                     double offset = Math.Max(0.0, _orientation.MajorStart(realizationRect) - _orientation.MajorStart(lastExtent));
                     int anchorRowIndex = (int)(offset / GetMajorSizeWithSpacing(context));
 
-                    anchorIndex = Math.Max(0, Math.Min(itemsCount - 1, anchorRowIndex * itemsPerLine));
+                    anchorIndex = (int)Math.Max(0, Math.Min(itemsCount - 1, anchorRowIndex * itemsPerLine));
                     bounds = GetLayoutRectForDataIndex(availableSize, anchorIndex, lastExtent, context);
                 }
             }
@@ -299,7 +317,9 @@ namespace Avalonia.Layout
             int count = context.ItemCount;
             if (targetIndex >= 0 && targetIndex < count)
             {
-                int itemsPerLine = Math.Max(1, (int)(_orientation.Minor(availableSize) / GetMinorSizeWithSpacing(context)));
+                int itemsPerLine = (int)Math.Min( // note use of unsigned ints
+                    Math.Max(1u, (uint)(_orientation.Minor(availableSize) / GetMinorSizeWithSpacing(context))),
+                    Math.Max(1u, _maximumRowsOrColumns));
                 int indexOfFirstInLine = (targetIndex / itemsPerLine) * itemsPerLine;
                 index = indexOfFirstInLine;
                 var state = context.LayoutState as UniformGridLayoutState;
@@ -329,8 +349,12 @@ namespace Avalonia.Layout
             // Constants
             int itemsCount = context.ItemCount;
             double availableSizeMinor = _orientation.Minor(availableSize);
-            int itemsPerLine = Math.Max(1, !double.IsInfinity(availableSizeMinor) ?
-                (int)(availableSizeMinor / GetMinorSizeWithSpacing(context)) : itemsCount);
+            int itemsPerLine =
+                (int)Math.Min( // note use of unsigned ints
+                    Math.Max(1u, !double.IsInfinity(availableSizeMinor)
+                        ? (uint)(availableSizeMinor / GetMinorSizeWithSpacing(context))
+                        : (uint)itemsCount),
+                Math.Max(1u, _maximumRowsOrColumns));
             double lineSize = GetMajorSizeWithSpacing(context);
 
             if (itemsCount > 0)
@@ -398,7 +422,7 @@ namespace Avalonia.Layout
             // Set the width and height on the grid state. If the user already set them then use the preset. 
             // If not, we have to measure the first element and get back a size which we're going to be using for the rest of the items.
             var gridState = (UniformGridLayoutState)context.LayoutState;
-            gridState.EnsureElementSize(availableSize, context, _minItemWidth, _minItemHeight, _itemsStretch, Orientation, MinRowSpacing, MinColumnSpacing);
+            gridState.EnsureElementSize(availableSize, context, _minItemWidth, _minItemHeight, _itemsStretch, Orientation, MinRowSpacing, MinColumnSpacing, _maximumRowsOrColumns);
 
             var desiredSize = GetFlowAlgorithm(context).Measure(
                 availableSize,
@@ -406,6 +430,7 @@ namespace Avalonia.Layout
                 true,
                 MinItemSpacing,
                 LineSpacing,
+                _maximumRowsOrColumns,
                 _orientation.ScrollOrientation,
                 LayoutId);
 
@@ -471,6 +496,10 @@ namespace Avalonia.Layout
             {
                 _minItemHeight = (double)args.NewValue;
             }
+            else if (args.Property == MaximumRowsOrColumnsProperty)
+            {
+                _maximumRowsOrColumns = (int)args.NewValue;
+            }
 
             InvalidateLayout();
         }
@@ -499,7 +528,9 @@ namespace Avalonia.Layout
             Rect lastExtent,
             VirtualizingLayoutContext context)
         {
-            int itemsPerLine = Math.Max(1, (int)(_orientation.Minor(availableSize) / GetMinorSizeWithSpacing(context)));
+            int itemsPerLine = (int)Math.Min( //note use of unsigned ints
+                Math.Max(1u, (uint)(_orientation.Minor(availableSize) / GetMinorSizeWithSpacing(context))),
+                Math.Max(1u, _maximumRowsOrColumns));
             int rowIndex = (int)(index / itemsPerLine);
             int indexInRow = index - (rowIndex * itemsPerLine);
 
diff --git a/src/Avalonia.Layout/UniformGridLayoutState.cs b/src/Avalonia.Layout/UniformGridLayoutState.cs
index e6d75bcf35..62c5174775 100644
--- a/src/Avalonia.Layout/UniformGridLayoutState.cs
+++ b/src/Avalonia.Layout/UniformGridLayoutState.cs
@@ -48,8 +48,14 @@ namespace Avalonia.Layout
             UniformGridLayoutItemsStretch stretch,
             Orientation orientation,
             double minRowSpacing,
-            double minColumnSpacing)
+            double minColumnSpacing,
+            int maxItemsPerLine)
         {
+            if (maxItemsPerLine == 0)
+            {
+                maxItemsPerLine = 1;
+            }
+
             if (context.ItemCount > 0)
             {
                 // If the first element is realized we don't need to cache it or to get it from the context
@@ -57,7 +63,7 @@ namespace Avalonia.Layout
                 if (realizedElement != null)
                 {
                     realizedElement.Measure(availableSize);
-                    SetSize(realizedElement, layoutItemWidth, LayoutItemHeight, availableSize, stretch, orientation, minRowSpacing, minColumnSpacing);
+                    SetSize(realizedElement, layoutItemWidth, LayoutItemHeight, availableSize, stretch, orientation, minRowSpacing, minColumnSpacing, maxItemsPerLine);
                     _cachedFirstElement = null;
                 }
                 else
@@ -72,7 +78,7 @@ namespace Avalonia.Layout
 
                     _cachedFirstElement.Measure(availableSize);
 
-                    SetSize(_cachedFirstElement, layoutItemWidth, LayoutItemHeight, availableSize, stretch, orientation, minRowSpacing, minColumnSpacing);
+                    SetSize(_cachedFirstElement, layoutItemWidth, LayoutItemHeight, availableSize, stretch, orientation, minRowSpacing, minColumnSpacing, maxItemsPerLine);
 
                     // See if we can move ownership to the flow algorithm. If we can, we do not need a local cache.
                     bool added = FlowAlgorithm.TryAddElement0(_cachedFirstElement);
@@ -92,8 +98,14 @@ namespace Avalonia.Layout
             UniformGridLayoutItemsStretch stretch,
             Orientation orientation,
             double minRowSpacing,
-            double minColumnSpacing)
+            double minColumnSpacing,
+            int maxItemsPerLine)
         {
+            if (maxItemsPerLine == 0)
+            {
+                maxItemsPerLine = 1;
+            }
+
             EffectiveItemWidth = (double.IsNaN(layoutItemWidth) ? element.DesiredSize.Width : layoutItemWidth);
             EffectiveItemHeight = (double.IsNaN(LayoutItemHeight) ? element.DesiredSize.Height : LayoutItemHeight);
 
@@ -101,11 +113,17 @@ namespace Avalonia.Layout
             var minorItemSpacing = orientation == Orientation.Vertical ? minRowSpacing : minColumnSpacing;
 
             var itemSizeMinor = orientation == Orientation.Horizontal ? EffectiveItemWidth : EffectiveItemHeight;
-            itemSizeMinor += minorItemSpacing;
 
-            var numItemsPerColumn = (int)(Math.Max(1.0, availableSizeMinor / itemSizeMinor));
-            var remainingSpace = ((int)availableSizeMinor) % ((int)itemSizeMinor);
-            var extraMinorPixelsForEachItem = remainingSpace / numItemsPerColumn;
+            double extraMinorPixelsForEachItem = 0.0;
+            if (!double.IsInfinity(availableSizeMinor))
+            {
+                var numItemsPerColumn = Math.Min(
+                    maxItemsPerLine,
+                    Math.Max(1.0, availableSizeMinor / (itemSizeMinor + minorItemSpacing)));
+                var usedSpace = (numItemsPerColumn * (itemSizeMinor + minorItemSpacing)) - minorItemSpacing;
+                var remainingSpace = ((int)(availableSizeMinor - usedSpace));
+                extraMinorPixelsForEachItem = remainingSpace / ((int)numItemsPerColumn);
+            }
 
             if (stretch == UniformGridLayoutItemsStretch.Fill)
             {

From 55275e09def1f8830ce3cafd071529ab600ea0f0 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 9 Jan 2020 10:01:53 +0100
Subject: [PATCH 33/46] =?UTF-8?q?Fix=20stack=20layout=20arrange=20when=20i?=
 =?UTF-8?q?tems=20use=20stretch=20and=20final=20size=20is=20mor=E2=80=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

…e than desired size.

Ported from https://github.com/microsoft/microsoft-ui-xaml/commit/f37ebd5bb21e6d4d7b3bb4228fb22a47d3c33b85
---
 src/Avalonia.Layout/FlowLayoutAlgorithm.cs | 18 +++++++++++++++---
 src/Avalonia.Layout/StackLayout.cs         |  1 +
 src/Avalonia.Layout/UniformGridLayout.cs   |  1 +
 3 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/src/Avalonia.Layout/FlowLayoutAlgorithm.cs b/src/Avalonia.Layout/FlowLayoutAlgorithm.cs
index 7343f4a6e9..7f44c80a64 100644
--- a/src/Avalonia.Layout/FlowLayoutAlgorithm.cs
+++ b/src/Avalonia.Layout/FlowLayoutAlgorithm.cs
@@ -116,10 +116,11 @@ namespace Avalonia.Layout
         public Size Arrange(
             Size finalSize,
             VirtualizingLayoutContext context,
+            bool isWrapping,
             LineAlignment lineAlignment,
             string layoutId)
         {
-            ArrangeVirtualizingLayout(finalSize, lineAlignment, layoutId);
+            ArrangeVirtualizingLayout(finalSize, lineAlignment, isWrapping, layoutId);
 
             return new Size(
                 Math.Max(finalSize.Width, _lastExtent.Width),
@@ -546,6 +547,7 @@ namespace Avalonia.Layout
         private void ArrangeVirtualizingLayout(
             Size finalSize,
             LineAlignment lineAlignment,
+            bool isWrapping,
             string layoutId)
         {
             // Walk through the realized elements one line at a time and 
@@ -565,7 +567,7 @@ namespace Avalonia.Layout
                     if (_orientation.MajorStart(currentBounds) != currentLineOffset)
                     {
                         spaceAtLineEnd = _orientation.Minor(finalSize) - _orientation.MinorStart(previousElementBounds) - _orientation.MinorSize(previousElementBounds);
-                        PerformLineAlignment(i - countInLine, countInLine, spaceAtLineStart, spaceAtLineEnd, currentLineSize, lineAlignment, layoutId);
+                        PerformLineAlignment(i - countInLine, countInLine, spaceAtLineStart, spaceAtLineEnd, currentLineSize, lineAlignment, isWrapping, finalSize, layoutId);
                         spaceAtLineStart = _orientation.MinorStart(currentBounds);
                         countInLine = 0;
                         currentLineOffset = _orientation.MajorStart(currentBounds);
@@ -582,7 +584,7 @@ namespace Avalonia.Layout
                 if (countInLine > 0)
                 {
                     var spaceAtEnd = _orientation.Minor(finalSize) - _orientation.MinorStart(previousElementBounds) - _orientation.MinorSize(previousElementBounds);
-                    PerformLineAlignment(realizedElementCount - countInLine, countInLine, spaceAtLineStart, spaceAtEnd, currentLineSize, lineAlignment, layoutId);
+                    PerformLineAlignment(realizedElementCount - countInLine, countInLine, spaceAtLineStart, spaceAtEnd, currentLineSize, lineAlignment, isWrapping, finalSize, layoutId);
                 }
             }
         }
@@ -596,6 +598,8 @@ namespace Avalonia.Layout
             double spaceAtLineEnd,
             double lineSize,
             LineAlignment lineAlignment,
+            bool isWrapping,
+            Size finalSize,
             string layoutId)
         {
             for (int rangeIndex = lineStartIndex; rangeIndex < lineStartIndex + countInLine; ++rangeIndex)
@@ -661,6 +665,14 @@ namespace Avalonia.Layout
                 }
 
                 bounds = bounds.Translate(-_lastExtent.Position);
+
+                if (!isWrapping)
+                {
+                    _orientation.SetMinorSize(
+                        ref bounds,
+                        Math.Max(_orientation.MinorSize(bounds), _orientation.Minor(finalSize)));
+                }
+
                 var element = _elementManager.GetAt(rangeIndex);
                 element.Arrange(bounds);
             }
diff --git a/src/Avalonia.Layout/StackLayout.cs b/src/Avalonia.Layout/StackLayout.cs
index a3fe80fab7..3c3729272c 100644
--- a/src/Avalonia.Layout/StackLayout.cs
+++ b/src/Avalonia.Layout/StackLayout.cs
@@ -279,6 +279,7 @@ namespace Avalonia.Layout
             var value = GetFlowAlgorithm(context).Arrange(
                finalSize,
                context,
+               false,
                FlowLayoutAlgorithm.LineAlignment.Start,
                LayoutId);
 
diff --git a/src/Avalonia.Layout/UniformGridLayout.cs b/src/Avalonia.Layout/UniformGridLayout.cs
index 16d21508a9..86dc21bd19 100644
--- a/src/Avalonia.Layout/UniformGridLayout.cs
+++ b/src/Avalonia.Layout/UniformGridLayout.cs
@@ -446,6 +446,7 @@ namespace Avalonia.Layout
             var value = GetFlowAlgorithm(context).Arrange(
                finalSize,
                context,
+               true,
                (FlowLayoutAlgorithm.LineAlignment)_itemsJustification,
                LayoutId);
             return new Size(value.Width, value.Height);

From 261e4775229d84bcee3a93ba51c38f21bdd5e2b2 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 9 Jan 2020 10:23:29 +0100
Subject: [PATCH 34/46] ItemsRepeater fix.

* Remove item from repeater children if there is no itemtemplate when being recycled.

Ported from https://github.com/microsoft/microsoft-ui-xaml/commit/c4d4d9995a0ee7df27aac11f875538dd4fbe14fb
---
 src/Avalonia.Controls/Repeater/ViewManager.cs | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/Repeater/ViewManager.cs b/src/Avalonia.Controls/Repeater/ViewManager.cs
index e4fc1158ef..f4588787e8 100644
--- a/src/Avalonia.Controls/Repeater/ViewManager.cs
+++ b/src/Avalonia.Controls/Repeater/ViewManager.cs
@@ -110,7 +110,19 @@ namespace Avalonia.Controls
         public void ClearElementToElementFactory(IControl element)
         {
             _owner.OnElementClearing(element);
-            _owner.ItemTemplateShim?.RecycleElement(_owner, element);
+
+            if (_owner.ItemTemplateShim != null)
+            {
+                _owner.ItemTemplateShim.RecycleElement(_owner, element);
+            }
+            else
+            {
+                // No ItemTemplate to recycle to, remove the element from the children collection.
+                if (!_owner.Children.Remove(element))
+                {
+                    throw new InvalidOperationException("ItemsRepeater's child not found in its Children collection.");
+                }
+            }
 
             var virtInfo = ItemsRepeater.GetVirtualizationInfo(element);
             virtInfo.MoveOwnershipToElementFactory();

From 1f46076f16deb2e0a60146b41b3fa01586b6c0d6 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 9 Jan 2020 10:35:15 +0100
Subject: [PATCH 35/46] Use NonVirtualizingLayoutContext.

- Add and use `NonVirtualizingLayoutContext` in `NonVirtualizingLayout`
- Return -1 instead of throwing if element is not a child of `ItemsRepeater`

Ported from https://github.com/microsoft/microsoft-ui-xaml/commit/22adf4dc624baf339a1da3f9c7d83e125f2f1b01
---
 src/Avalonia.Controls/Repeater/ViewManager.cs       |  3 ++-
 src/Avalonia.Layout/NonVirtualizingLayout.cs        |  8 ++++----
 src/Avalonia.Layout/NonVirtualizingLayoutContext.cs | 11 +++++++++++
 3 files changed, 17 insertions(+), 5 deletions(-)
 create mode 100644 src/Avalonia.Layout/NonVirtualizingLayoutContext.cs

diff --git a/src/Avalonia.Controls/Repeater/ViewManager.cs b/src/Avalonia.Controls/Repeater/ViewManager.cs
index f4588787e8..d670aa077c 100644
--- a/src/Avalonia.Controls/Repeater/ViewManager.cs
+++ b/src/Avalonia.Controls/Repeater/ViewManager.cs
@@ -200,7 +200,8 @@ namespace Avalonia.Controls
         {
             if (virtInfo == null)
             {
-                throw new ArgumentException("Element is not a child of this ItemsRepeater.");
+                //Element is not a child of this ItemsRepeater.
+                return -1;
             }
 
             return virtInfo.IsRealized || virtInfo.IsInUniqueIdResetPool ? virtInfo.Index : -1;
diff --git a/src/Avalonia.Layout/NonVirtualizingLayout.cs b/src/Avalonia.Layout/NonVirtualizingLayout.cs
index fba91e66c7..3917830eb7 100644
--- a/src/Avalonia.Layout/NonVirtualizingLayout.cs
+++ b/src/Avalonia.Layout/NonVirtualizingLayout.cs
@@ -32,7 +32,7 @@ namespace Avalonia.Layout
         /// <inheritdoc/>
         public sealed override Size Measure(LayoutContext context, Size availableSize)
         {
-            return MeasureOverride((VirtualizingLayoutContext)context, availableSize);
+            return MeasureOverride((NonVirtualizingLayoutContext)context, availableSize);
         }
 
         /// <inheritdoc/>
@@ -49,7 +49,7 @@ namespace Avalonia.Layout
         /// The context object that facilitates communication between the layout and its host
         /// container.
         /// </param>
-        protected virtual void InitializeForContextCore(VirtualizingLayoutContext context)
+        protected virtual void InitializeForContextCore(LayoutContext context)
         {
         }
 
@@ -61,7 +61,7 @@ namespace Avalonia.Layout
         /// The context object that facilitates communication between the layout and its host
         /// container.
         /// </param>
-        protected virtual void UninitializeForContextCore(VirtualizingLayoutContext context)
+        protected virtual void UninitializeForContextCore(LayoutContext context)
         {
         }
 
@@ -83,7 +83,7 @@ namespace Avalonia.Layout
         /// of the allocated sizes for child objects or based on other considerations such as a
         /// fixed container size.
         /// </returns>
-        protected abstract Size MeasureOverride(VirtualizingLayoutContext context, Size availableSize);
+        protected abstract Size MeasureOverride(NonVirtualizingLayoutContext context, Size availableSize);
 
         /// <summary>
         /// When implemented in a derived class, provides the behavior for the "Arrange" pass of
diff --git a/src/Avalonia.Layout/NonVirtualizingLayoutContext.cs b/src/Avalonia.Layout/NonVirtualizingLayoutContext.cs
new file mode 100644
index 0000000000..201ffa7d36
--- /dev/null
+++ b/src/Avalonia.Layout/NonVirtualizingLayoutContext.cs
@@ -0,0 +1,11 @@
+// This source file is adapted from the WinUI project.
+// (https://github.com/microsoft/microsoft-ui-xaml)
+//
+// Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation.
+
+namespace Avalonia.Layout
+{
+    public abstract class NonVirtualizingLayoutContext : LayoutContext
+    {
+    }
+}

From 09297dbb089110c2c70c675eb4b671d10834ef46 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 9 Jan 2020 10:37:44 +0100
Subject: [PATCH 36/46] Fix repeater holding onto elements

If a consumer changes the ItemsSource with a non recycling layout then the items from the old source would be perpetually held by repeater, a potentially substantial leak.

Ported from https://github.com/microsoft/microsoft-ui-xaml/commit/e158eec3e93f7c3839f5a9e5226f0f4e0103f2a6
---
 src/Avalonia.Controls/Repeater/ItemsRepeater.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Avalonia.Controls/Repeater/ItemsRepeater.cs b/src/Avalonia.Controls/Repeater/ItemsRepeater.cs
index 0e2136a6f3..685d3e44f2 100644
--- a/src/Avalonia.Controls/Repeater/ItemsRepeater.cs
+++ b/src/Avalonia.Controls/Repeater/ItemsRepeater.cs
@@ -588,6 +588,8 @@ namespace Avalonia.Controls
                             ClearElementImpl(element);
                         }
                     }
+
+                    Children.Clear();
                 }
 
                 InvalidateMeasure();

From bb7276d568e2d51127b2134013d63f0d410226f5 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 9 Jan 2020 10:46:13 +0100
Subject: [PATCH 37/46] =?UTF-8?q?Extend=20the=20fix=20for=20Recycling=20th?=
 =?UTF-8?q?e=20focused=20element=20to=20non=20virtualized=20l=E2=80=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

…ayouts

* Ensure that we set the m_processingItesmSourceChange flag for non-virtualizing layouts as well as virtualizing ones.

Ported from https://github.com/microsoft/microsoft-ui-xaml/commit/cc335ac3915ed37ac7ee95237b789622287d2f5a
---
 .../Repeater/ItemsRepeater.cs                 | 36 +++++++++----------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/Avalonia.Controls/Repeater/ItemsRepeater.cs b/src/Avalonia.Controls/Repeater/ItemsRepeater.cs
index 685d3e44f2..cbac1d6c1b 100644
--- a/src/Avalonia.Controls/Repeater/ItemsRepeater.cs
+++ b/src/Avalonia.Controls/Repeater/ItemsRepeater.cs
@@ -562,34 +562,34 @@ namespace Avalonia.Controls
 
             if (Layout != null)
             {
-                if (Layout is VirtualizingLayout virtualLayout)
-                {
-                    var args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset);
+                var args = new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset);
 
+                try
+                {
                     _processingItemsSourceChange = args;
 
-                    try
+                    if (Layout is VirtualizingLayout virtualLayout)
                     {
                         virtualLayout.OnItemsChanged(GetLayoutContext(), newValue, args);
                     }
-                    finally
+                    else if (Layout is NonVirtualizingLayout nonVirtualLayout)
                     {
-                        _processingItemsSourceChange = null;
-                    }
-                }
-                else if (Layout is NonVirtualizingLayout nonVirtualLayout)
-                {
-                    // Walk through all the elements and make sure they are cleared for
-                    // non-virtualizing layouts.
-                    foreach (var element in Children)
-                    {
-                        if (GetVirtualizationInfo(element).IsRealized)
+                        // Walk through all the elements and make sure they are cleared for
+                        // non-virtualizing layouts.
+                        foreach (var element in Children)
                         {
-                            ClearElementImpl(element);
+                            if (GetVirtualizationInfo(element).IsRealized)
+                            {
+                                ClearElementImpl(element);
+                            }
                         }
-                    }
 
-                    Children.Clear();
+                        Children.Clear();
+                    }
+                }
+                finally
+                {
+                    _processingItemsSourceChange = null;
                 }
 
                 InvalidateMeasure();

From 0236ced64fc31ba998177b05f3cd23623595e723 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 9 Jan 2020 11:32:39 +0100
Subject: [PATCH 38/46] Fix ItemsRepeater overwriting DataContext

Ported from https://github.com/microsoft/microsoft-ui-xaml/commit/0e24e05dbdb231aa0f4e3ec22e13ad528f155eb6
---
 src/Avalonia.Controls/Repeater/ViewManager.cs | 49 +++++++++++++------
 1 file changed, 33 insertions(+), 16 deletions(-)

diff --git a/src/Avalonia.Controls/Repeater/ViewManager.cs b/src/Avalonia.Controls/Repeater/ViewManager.cs
index d670aa077c..7d005a30b4 100644
--- a/src/Avalonia.Controls/Repeater/ViewManager.cs
+++ b/src/Avalonia.Controls/Repeater/ViewManager.cs
@@ -526,43 +526,60 @@ namespace Avalonia.Controls
             return element;
         }
 
+        // There are several cases handled here with respect to which element gets returned and when DataContext is modified.
+        //
+        // 1. If there is no ItemTemplate:
+        //    1.1 If data is an IControl -> the data is returned
+        //    1.2 If data is not an IControl -> a default DataTemplate is used to fetch element and DataContext is set to data
+        //
+        // 2. If there is an ItemTemplate:
+        //    2.1 If data is not an IControl -> Element is fetched from ElementFactory and DataContext is set to the data
+        //    2.2 If data is an IControl:
+        //        2.2.1 If Element returned by the ElementFactory is the same as the data -> Element (a.k.a. data) is returned as is
+        //        2.2.2 If Element returned by the ElementFactory is not the same as the data
+        //                 -> Element that is fetched from the ElementFactory is returned and
+        //                    DataContext is set to the data's DataContext (if it exists), otherwise it is set to the data itself
         private IControl GetElementFromElementFactory(int index)
         {
             // The view generator is the provider of last resort.
             var data = _owner.ItemsSourceView.GetAt(index);
-            var itemTemplateFactory = _owner.ItemTemplateShim;
-            IControl element = null;
-            var itemsSourceContainsElements = false;
+            var providedElementFactory = _owner.ItemTemplateShim;
 
-            if (itemTemplateFactory == null)
+            ItemTemplateWrapper GetElementFactory()
             {
-                element = data as IControl;
+                if (providedElementFactory == null)
+                {
+                    var factory = FuncDataTemplate.Default;
+                    _owner.ItemTemplate = factory;
+                    return _owner.ItemTemplateShim;
+                }
 
-                // No item template provided and ItemsSource contains objects derived from UIElement.
-                // In this case, just use the data directly as elements.
-                itemsSourceContainsElements = element != null;
+                return providedElementFactory;
             }
 
-            if (element == null)
+            IControl GetElement()
             {
-                if (itemTemplateFactory == null)
+                if (providedElementFactory == null)
                 {
-                    // If no ItemTemplate was provided, use a default 
-                    var factory = FuncDataTemplate.Default;
-                    _owner.ItemTemplate = factory;
-                    itemTemplateFactory = _owner.ItemTemplateShim;
+                    if (data is IControl dataAsElement)
+                    {
+                        return dataAsElement;
+                    }
                 }
 
-                element = itemTemplateFactory.GetElement(_owner, data);
+                var elementFactory = GetElementFactory();
+                return elementFactory.GetElement(_owner, data);
             }
 
+            var element = GetElement();
+
             var virtInfo = ItemsRepeater.TryGetVirtualizationInfo(element);
             if (virtInfo == null)
             {
                 virtInfo = ItemsRepeater.CreateAndInitializeVirtualizationInfo(element);
             }
 
-            if (!itemsSourceContainsElements)
+            if (data != element)
             {
                 // Prepare the element
                 element.DataContext = data;

From c6e6ad5678e88380ffb4e0aaa9005a931cf52f9e Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 9 Jan 2020 11:35:05 +0100
Subject: [PATCH 39/46] Fix bug with UniformGridLayout MaximumRowsOrColumns and
 requested size

Ported from https://github.com/microsoft/microsoft-ui-xaml/commit/007ab33a66642acb3be343f5aaf35df650513df5
---
 src/Avalonia.Layout/UniformGridLayout.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Avalonia.Layout/UniformGridLayout.cs b/src/Avalonia.Layout/UniformGridLayout.cs
index 86dc21bd19..11a521ed1e 100644
--- a/src/Avalonia.Layout/UniformGridLayout.cs
+++ b/src/Avalonia.Layout/UniformGridLayout.cs
@@ -361,9 +361,9 @@ namespace Avalonia.Layout
             {
                 _orientation.SetMinorSize(
                     ref extent,
-                    !double.IsInfinity(availableSizeMinor) ?
+                    !double.IsInfinity(availableSizeMinor) && _itemsStretch == UniformGridLayoutItemsStretch.Fill ?
                     availableSizeMinor :
-                    Math.Max(0.0, itemsCount * GetMinorSizeWithSpacing(context) - (double)MinItemSpacing));
+                    Math.Max(0.0, itemsPerLine * GetMinorSizeWithSpacing(context) - (double)MinItemSpacing));
                 _orientation.SetMajorSize(
                     ref extent,
                     Math.Max(0.0, (itemsCount / itemsPerLine) * lineSize - (double)LineSpacing));

From 35f26081c6d84afd2ed3d85ee6d2ea705367de71 Mon Sep 17 00:00:00 2001
From: Dariusz Komosinski <darek.komosinski@gmail.com>
Date: Thu, 9 Jan 2020 22:27:56 +0100
Subject: [PATCH 40/46] Implement events for ToggleButton.

---
 .../Primitives/ToggleButton.cs                | 122 ++++++++++++++++++
 .../Primitives/ToggleButtonTests.cs           |  54 +++++++-
 2 files changed, 175 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/Primitives/ToggleButton.cs b/src/Avalonia.Controls/Primitives/ToggleButton.cs
index e7cd0697a0..247e55a347 100644
--- a/src/Avalonia.Controls/Primitives/ToggleButton.cs
+++ b/src/Avalonia.Controls/Primitives/ToggleButton.cs
@@ -7,8 +7,14 @@ using Avalonia.Data;
 
 namespace Avalonia.Controls.Primitives
 {
+    /// <summary>
+    /// Represents a control that a user can select (check) or clear (uncheck). Base class for controls that can switch states.
+    /// </summary>
     public class ToggleButton : Button
     {
+        /// <summary>
+        /// Defines the <see cref="IsChecked"/> property.
+        /// </summary>
         public static readonly DirectProperty<ToggleButton, bool?> IsCheckedProperty =
             AvaloniaProperty.RegisterDirect<ToggleButton, bool?>(
                 nameof(IsChecked),
@@ -17,9 +23,30 @@ namespace Avalonia.Controls.Primitives
                 unsetValue: null,
                 defaultBindingMode: BindingMode.TwoWay);
 
+        /// <summary>
+        /// Defines the <see cref="IsThreeState"/> property.
+        /// </summary>
         public static readonly StyledProperty<bool> IsThreeStateProperty =
             AvaloniaProperty.Register<ToggleButton, bool>(nameof(IsThreeState));
 
+        /// <summary>
+        /// Defines the <see cref="Checked"/> event.
+        /// </summary>
+        public static readonly RoutedEvent<RoutedEventArgs> CheckedEvent =
+            RoutedEvent.Register<ToggleButton, RoutedEventArgs>(nameof(Checked), RoutingStrategies.Bubble);
+
+        /// <summary>
+        /// Defines the <see cref="Unchecked"/> event.
+        /// </summary>
+        public static readonly RoutedEvent<RoutedEventArgs> UncheckedEvent =
+            RoutedEvent.Register<ToggleButton, RoutedEventArgs>(nameof(Unchecked), RoutingStrategies.Bubble);
+
+        /// <summary>
+        /// Defines the <see cref="Unchecked"/> event.
+        /// </summary>
+        public static readonly RoutedEvent<RoutedEventArgs> IndeterminateEvent =
+            RoutedEvent.Register<ToggleButton, RoutedEventArgs>(nameof(Indeterminate), RoutingStrategies.Bubble);
+
         private bool? _isChecked = false;
 
         static ToggleButton()
@@ -27,14 +54,49 @@ namespace Avalonia.Controls.Primitives
             PseudoClass<ToggleButton, bool?>(IsCheckedProperty, c => c == true, ":checked");
             PseudoClass<ToggleButton, bool?>(IsCheckedProperty, c => c == false, ":unchecked");
             PseudoClass<ToggleButton, bool?>(IsCheckedProperty, c => c == null, ":indeterminate");
+
+            IsCheckedProperty.Changed.AddClassHandler<ToggleButton>((x, e) => x.OnIsCheckedChanged(e));
+        }
+
+        /// <summary>
+        /// Raised when a <see cref="ToggleButton"/> is checked.
+        /// </summary>
+        public event EventHandler<RoutedEventArgs> Checked
+        {
+            add { AddHandler(CheckedEvent, value); }
+            remove { RemoveHandler(CheckedEvent, value); }
+        }
+
+        /// <summary>
+        /// Raised when a <see cref="ToggleButton"/> is unchecked.
+        /// </summary>
+        public event EventHandler<RoutedEventArgs> Unchecked
+        {
+            add { AddHandler(UncheckedEvent, value); }
+            remove { RemoveHandler(UncheckedEvent, value); }
+        }
+
+        /// <summary>
+        /// Raised when a <see cref="ToggleButton"/> is neither checked nor unchecked.
+        /// </summary>
+        public event EventHandler<RoutedEventArgs> Indeterminate
+        {
+            add { AddHandler(IndeterminateEvent, value); }
+            remove { RemoveHandler(IndeterminateEvent, value); }
         }
 
+        /// <summary>
+        /// Gets or sets whether the <see cref="ToggleButton"/> is checked.
+        /// </summary>
         public bool? IsChecked
         {
             get { return _isChecked; }
             set { SetAndRaise(IsCheckedProperty, ref _isChecked, value); }
         }
 
+        /// <summary>
+        /// Gets or sets a value that indicates whether the control supports three states.
+        /// </summary>
         public bool IsThreeState
         {
             get => GetValue(IsThreeStateProperty);
@@ -47,18 +109,78 @@ namespace Avalonia.Controls.Primitives
             base.OnClick();
         }
 
+        /// <summary>
+        /// Toggles the <see cref="IsChecked"/> property.
+        /// </summary>
         protected virtual void Toggle()
         {
             if (IsChecked.HasValue)
+            {
                 if (IsChecked.Value)
+                {
                     if (IsThreeState)
+                    {
                         IsChecked = null;
+                    }
                     else
+                    {
                         IsChecked = false;
+                    }
+                }
                 else
+                {
                     IsChecked = true;
+                }
+            }
             else
+            {
                 IsChecked = false;
+            }
+        }
+
+        /// <summary>
+        /// Called when <see cref="IsChecked"/> becomes true.
+        /// </summary>
+        /// <param name="e">Event arguments for the routed event that is raised by the default implementation of this method.</param>
+        protected virtual void OnChecked(RoutedEventArgs e)
+        {
+            RaiseEvent(e);
+        }
+
+        /// <summary>
+        /// Called when <see cref="IsChecked"/> becomes false.
+        /// </summary>
+        /// <param name="e">Event arguments for the routed event that is raised by the default implementation of this method.</param>
+        protected virtual void OnUnchecked(RoutedEventArgs e)
+        {
+            RaiseEvent(e);
+        }
+
+        /// <summary>
+        /// Called when <see cref="IsChecked"/> becomes null.
+        /// </summary>
+        /// <param name="e">Event arguments for the routed event that is raised by the default implementation of this method.</param>
+        protected virtual void OnIndeterminate(RoutedEventArgs e)
+        {
+            RaiseEvent(e);
+        }
+
+        private void OnIsCheckedChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            var newValue = (bool?)e.NewValue;
+
+            switch (newValue)
+            {
+                case true:
+                    OnChecked(new RoutedEventArgs(CheckedEvent));
+                    break;
+                case false:
+                    OnUnchecked(new RoutedEventArgs(UncheckedEvent));
+                    break;
+                default:
+                    OnIndeterminate(new RoutedEventArgs(IndeterminateEvent));
+                    break;
+            }
         }
     }
 }
diff --git a/tests/Avalonia.Controls.UnitTests/Primitives/ToggleButtonTests.cs b/tests/Avalonia.Controls.UnitTests/Primitives/ToggleButtonTests.cs
index 4f4ab47b0a..9acd42aba6 100644
--- a/tests/Avalonia.Controls.UnitTests/Primitives/ToggleButtonTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Primitives/ToggleButtonTests.cs
@@ -1,5 +1,4 @@
 using Avalonia.Data;
-using Avalonia.Markup.Data;
 using Avalonia.UnitTests;
 
 using Xunit;
@@ -63,6 +62,54 @@ namespace Avalonia.Controls.Primitives.UnitTests
             Assert.Null(threeStateButton.IsChecked);
         }
 
+        [Fact]
+        public void ToggleButton_Events_Are_Raised_On_Is_Checked_Changes()
+        {
+            var threeStateButton = new ToggleButton();
+
+            bool checkedRaised = false;
+            threeStateButton.Checked += (_, __) => checkedRaised = true;
+
+            threeStateButton.IsChecked = true;
+            Assert.True(checkedRaised);
+
+            bool uncheckedRaised = false;
+            threeStateButton.Unchecked += (_, __) => uncheckedRaised = true;
+
+            threeStateButton.IsChecked = false;
+            Assert.True(uncheckedRaised);
+
+            bool indeterminateRaised = false;
+            threeStateButton.Indeterminate += (_, __) => indeterminateRaised = true;
+
+            threeStateButton.IsChecked = null;
+            Assert.True(indeterminateRaised);
+        }
+
+        [Fact]
+        public void ToggleButton_Events_Are_Raised_When_Toggling()
+        {
+            var threeStateButton = new TestToggleButton { IsThreeState = true };
+
+            bool checkedRaised = false;
+            threeStateButton.Checked += (_, __) => checkedRaised = true;
+
+            threeStateButton.Toggle();
+            Assert.True(checkedRaised);
+
+            bool indeterminateRaised = false;
+            threeStateButton.Indeterminate += (_, __) => indeterminateRaised = true;
+
+            threeStateButton.Toggle();
+            Assert.True(indeterminateRaised);
+
+            bool uncheckedRaised = false;
+            threeStateButton.Unchecked += (_, __) => uncheckedRaised = true;
+
+            threeStateButton.Toggle();
+            Assert.True(uncheckedRaised);
+        }
+
         private class Class1 : NotifyingBase
         {
             private bool _foo;
@@ -80,5 +127,10 @@ namespace Avalonia.Controls.Primitives.UnitTests
                 set { nullableFoo = value; RaisePropertyChanged(); }
             }
         }
+
+        private class TestToggleButton : ToggleButton
+        {
+            public new void Toggle() => base.Toggle();
+        }
     }
 }

From b400b45e0a60d34519626286ac3df3de61debb1d Mon Sep 17 00:00:00 2001
From: Dariusz Komosinski <darek.komosinski@gmail.com>
Date: Thu, 9 Jan 2020 22:28:16 +0100
Subject: [PATCH 41/46] Use expression bodied events and properties.

---
 src/Avalonia.Controls/Primitives/ToggleButton.cs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/Avalonia.Controls/Primitives/ToggleButton.cs b/src/Avalonia.Controls/Primitives/ToggleButton.cs
index 247e55a347..4b3e8e2110 100644
--- a/src/Avalonia.Controls/Primitives/ToggleButton.cs
+++ b/src/Avalonia.Controls/Primitives/ToggleButton.cs
@@ -63,8 +63,8 @@ namespace Avalonia.Controls.Primitives
         /// </summary>
         public event EventHandler<RoutedEventArgs> Checked
         {
-            add { AddHandler(CheckedEvent, value); }
-            remove { RemoveHandler(CheckedEvent, value); }
+            add => AddHandler(CheckedEvent, value);
+            remove => RemoveHandler(CheckedEvent, value);
         }
 
         /// <summary>
@@ -72,8 +72,8 @@ namespace Avalonia.Controls.Primitives
         /// </summary>
         public event EventHandler<RoutedEventArgs> Unchecked
         {
-            add { AddHandler(UncheckedEvent, value); }
-            remove { RemoveHandler(UncheckedEvent, value); }
+            add => AddHandler(UncheckedEvent, value);
+            remove => RemoveHandler(UncheckedEvent, value);
         }
 
         /// <summary>
@@ -81,8 +81,8 @@ namespace Avalonia.Controls.Primitives
         /// </summary>
         public event EventHandler<RoutedEventArgs> Indeterminate
         {
-            add { AddHandler(IndeterminateEvent, value); }
-            remove { RemoveHandler(IndeterminateEvent, value); }
+            add => AddHandler(IndeterminateEvent, value);
+            remove => RemoveHandler(IndeterminateEvent, value);
         }
 
         /// <summary>
@@ -90,8 +90,8 @@ namespace Avalonia.Controls.Primitives
         /// </summary>
         public bool? IsChecked
         {
-            get { return _isChecked; }
-            set { SetAndRaise(IsCheckedProperty, ref _isChecked, value); }
+            get => _isChecked;
+            set => SetAndRaise(IsCheckedProperty, ref _isChecked, value);
         }
 
         /// <summary>

From 155915134e15b95029a9360347ad2129fed82231 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 10 Jan 2020 11:01:16 +0100
Subject: [PATCH 42/46] Use correct context type.

---
 src/Avalonia.Layout/NonVirtualizingLayout.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Avalonia.Layout/NonVirtualizingLayout.cs b/src/Avalonia.Layout/NonVirtualizingLayout.cs
index 3917830eb7..5d27ba9199 100644
--- a/src/Avalonia.Layout/NonVirtualizingLayout.cs
+++ b/src/Avalonia.Layout/NonVirtualizingLayout.cs
@@ -20,13 +20,13 @@ namespace Avalonia.Layout
         /// <inheritdoc/>
         public sealed override void InitializeForContext(LayoutContext context)
         {
-            InitializeForContextCore((VirtualizingLayoutContext)context);
+            InitializeForContextCore((NonVirtualizingLayoutContext)context);
         }
 
         /// <inheritdoc/>
         public sealed override void UninitializeForContext(LayoutContext context)
         {
-            UninitializeForContextCore((VirtualizingLayoutContext)context);
+            UninitializeForContextCore((NonVirtualizingLayoutContext)context);
         }
 
         /// <inheritdoc/>
@@ -38,7 +38,7 @@ namespace Avalonia.Layout
         /// <inheritdoc/>
         public sealed override Size Arrange(LayoutContext context, Size finalSize)
         {
-            return ArrangeOverride((VirtualizingLayoutContext)context, finalSize);
+            return ArrangeOverride((NonVirtualizingLayoutContext)context, finalSize);
         }
 
         /// <summary>
@@ -98,6 +98,6 @@ namespace Avalonia.Layout
         /// its children.
         /// </param>
         /// <returns>The actual size that is used after the element is arranged in layout.</returns>
-        protected virtual Size ArrangeOverride(VirtualizingLayoutContext context, Size finalSize) => finalSize;
+        protected virtual Size ArrangeOverride(NonVirtualizingLayoutContext context, Size finalSize) => finalSize;
     }
 }

From ef42e9350d0fd9fe983fb15d025e3384b52e4c9c Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 10 Jan 2020 11:01:32 +0100
Subject: [PATCH 43/46] Add doc comment for NonVirtualizingLayoutContext.

---
 src/Avalonia.Layout/NonVirtualizingLayoutContext.cs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/Avalonia.Layout/NonVirtualizingLayoutContext.cs b/src/Avalonia.Layout/NonVirtualizingLayoutContext.cs
index 201ffa7d36..d3dec83e9b 100644
--- a/src/Avalonia.Layout/NonVirtualizingLayoutContext.cs
+++ b/src/Avalonia.Layout/NonVirtualizingLayoutContext.cs
@@ -5,6 +5,9 @@
 
 namespace Avalonia.Layout
 {
+    /// <summary>
+    /// Represents the base class for layout context types that do not support virtualization.
+    /// </summary>
     public abstract class NonVirtualizingLayoutContext : LayoutContext
     {
     }

From 1e673eca90e2cbe85a933d1471e7826618c41e51 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dariusz=20Komosi=C5=84ski?= <darek.komosinski@gmail.com>
Date: Fri, 17 Jan 2020 10:57:54 +0100
Subject: [PATCH 44/46] Add failing unit test for init issue.

---
 .../Primitives/SelectingItemsControlTests.cs    | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs b/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs
index d819581000..696c0dbf46 100644
--- a/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Primitives/SelectingItemsControlTests.cs
@@ -129,6 +129,23 @@ namespace Avalonia.Controls.UnitTests.Primitives
             Assert.Equal(-1, target.SelectedIndex);
         }
 
+        [Fact]
+        public void SelectedIndex_Should_Be_Minus_1_Without_Initialize()
+        {
+            var items = new[]
+            {
+                new Item(),
+                new Item(),
+            };
+
+            var target = new ListBox();
+            target.Items = items;
+            target.Template = Template();
+            target.DataContext = new object();
+
+            Assert.Equal(-1, target.SelectedIndex);
+        }
+
         [Fact]
         public void SelectedIndex_Should_Be_0_After_Initialize_With_AlwaysSelected()
         {

From a238fd33f0fc0a16e217cee3ff5a4831e4a0773b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dariusz=20Komosi=C5=84ski?= <darek.komosinski@gmail.com>
Date: Fri, 17 Jan 2020 11:04:29 +0100
Subject: [PATCH 45/46] Unify SelectingItemsControl init handling and add extra
 checks to ensure correctness.

---
 .../Primitives/SelectingItemsControl.cs       | 38 +++++++++++++------
 1 file changed, 27 insertions(+), 11 deletions(-)

diff --git a/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs b/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs
index a5bbcec186..69da211aa4 100644
--- a/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs
+++ b/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs
@@ -5,6 +5,7 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Specialized;
+using System.Diagnostics;
 using System.Linq;
 using Avalonia.Collections;
 using Avalonia.Controls.Generators;
@@ -240,17 +241,14 @@ namespace Avalonia.Controls.Primitives
         public override void BeginInit()
         {
             base.BeginInit();
-            ++_updateCount;
-            _updateSelectedIndex = int.MinValue;
+
+            InternalBeginInit();
         }
 
         /// <inheritdoc/>
         public override void EndInit()
         {
-            if (--_updateCount == 0)
-            {
-                UpdateFinished();
-            }
+            InternalEndInit();
 
             base.EndInit();
         }
@@ -437,7 +435,8 @@ namespace Avalonia.Controls.Primitives
         protected override void OnDataContextBeginUpdate()
         {
             base.OnDataContextBeginUpdate();
-            ++_updateCount;
+
+            InternalBeginInit();
         }
 
         /// <inheritdoc/>
@@ -445,10 +444,7 @@ namespace Avalonia.Controls.Primitives
         {
             base.OnDataContextEndUpdate();
 
-            if (--_updateCount == 0)
-            {
-                UpdateFinished();
-            }
+            InternalEndInit();
         }
 
         protected override void OnKeyDown(KeyEventArgs e)
@@ -1118,6 +1114,26 @@ namespace Avalonia.Controls.Primitives
             }
         }
 
+        private void InternalBeginInit()
+        {
+            if (_updateCount == 0)
+            {
+                _updateSelectedIndex = int.MinValue;
+            }
+
+            ++_updateCount;
+        }
+
+        private void InternalEndInit()
+        {
+            Debug.Assert(_updateCount > 0);
+
+            if (--_updateCount == 0)
+            {
+                UpdateFinished();
+            }
+        }
+
         private class Selection : IEnumerable<int>
         {
             private readonly List<int> _list = new List<int>();

From 694585ce68f3625b8fbadb812b2358b9c012263d Mon Sep 17 00:00:00 2001
From: Rustam Sayfutdinov <rstm.sf@gmail.com>
Date: Fri, 17 Jan 2020 21:45:51 +0300
Subject: [PATCH 46/46] Fix typo in the doc for Color properties

---
 src/Avalonia.Visuals/Media/Color.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/Avalonia.Visuals/Media/Color.cs b/src/Avalonia.Visuals/Media/Color.cs
index a37463a0f0..c7439b5bf6 100644
--- a/src/Avalonia.Visuals/Media/Color.cs
+++ b/src/Avalonia.Visuals/Media/Color.cs
@@ -19,22 +19,22 @@ namespace Avalonia.Media
         }
 
         /// <summary>
-        /// Gets or sets the Alpha component of the color.
+        /// Gets the Alpha component of the color.
         /// </summary>
         public byte A { get; }
 
         /// <summary>
-        /// Gets or sets the Red component of the color.
+        /// Gets the Red component of the color.
         /// </summary>
         public byte R { get; }
 
         /// <summary>
-        /// Gets or sets the Green component of the color.
+        /// Gets the Green component of the color.
         /// </summary>
         public byte G { get; }
 
         /// <summary>
-        /// Gets or sets the Blue component of the color.
+        /// Gets the Blue component of the color.
         /// </summary>
         public byte B { get; }