From 3992e0e85514398623abbb9caf844325bfa695e9 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Mon, 8 Apr 2019 00:18:20 +0200
Subject: [PATCH 01/20] Added failing test for #2420.

---
 tests/Avalonia.LeakTests/ControlTests.cs | 33 ++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/tests/Avalonia.LeakTests/ControlTests.cs b/tests/Avalonia.LeakTests/ControlTests.cs
index b7aa452a18..cd25b79f1f 100644
--- a/tests/Avalonia.LeakTests/ControlTests.cs
+++ b/tests/Avalonia.LeakTests/ControlTests.cs
@@ -308,6 +308,39 @@ namespace Avalonia.LeakTests
         }
 
 
+        [Fact]
+        public void Slider_Is_Freed()
+        {
+            using (Start())
+            {
+                Func<Window> run = () =>
+                {
+                    var window = new Window
+                    {
+                        Content = new Slider()
+                    };
+
+                    window.Show();
+
+                    // Do a layout and make sure that Slider gets added to visual tree.
+                    window.LayoutManager.ExecuteInitialLayoutPass(window);
+                    Assert.IsType<Slider>(window.Presenter.Child);
+
+                    // Clear the content and ensure the Slider is removed.
+                    window.Content = null;
+                    window.LayoutManager.ExecuteLayoutPass();
+                    Assert.Null(window.Presenter.Child);
+
+                    return window;
+                };
+
+                var result = run();
+
+                dotMemory.Check(memory =>
+                    Assert.Equal(0, memory.GetObjects(where => where.Type.Is<Slider>()).ObjectsCount));
+            }
+        }
+
         [Fact]
         public void RendererIsDisposed()
         {

From 1cd900c856a80b370d3dad7e890a2a1654617599 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Mon, 8 Apr 2019 18:39:39 +0200
Subject: [PATCH 02/20] Prevent leak when using TemplateBinding from a Setter.

When a `TemplateBinding` is used as a `Setter.Value`, then we need to make sure we don't use the `TemplateBinding` itself as the binding because this can cause a memory leak.

Replace `IRequiresTemplateInSetter` with `ISetterValue` which can be used to require a template in the setter for `Control` and can also be used to notify `TemplateBinding`  that it's in a setter and so should always clone itself.

Fixes #2420
---
 src/Avalonia.Controls/Control.cs                | 10 +++++++++-
 .../Styling/IRequiresTemplateInSetter.cs        | 10 ----------
 src/Avalonia.Styling/Styling/ISetterValue.cs    | 13 +++++++++++++
 src/Avalonia.Styling/Styling/Setter.cs          |  8 +-------
 .../Avalonia.Markup/Data/TemplateBinding.cs     | 17 ++++++++++++-----
 tests/Avalonia.Styling.UnitTests/SetterTests.cs | 14 ++++++--------
 6 files changed, 41 insertions(+), 31 deletions(-)
 delete mode 100644 src/Avalonia.Styling/Styling/IRequiresTemplateInSetter.cs
 create mode 100644 src/Avalonia.Styling/Styling/ISetterValue.cs

diff --git a/src/Avalonia.Controls/Control.cs b/src/Avalonia.Controls/Control.cs
index a7ee027e70..ca5edae4a9 100644
--- a/src/Avalonia.Controls/Control.cs
+++ b/src/Avalonia.Controls/Control.cs
@@ -1,6 +1,7 @@
 // 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 System.ComponentModel;
 using Avalonia.Controls.Primitives;
 using Avalonia.Controls.Templates;
@@ -20,7 +21,7 @@ namespace Avalonia.Controls
     ///
     /// - A <see cref="Tag"/> property to allow user-defined data to be attached to the control.
     /// </remarks>
-    public class Control : InputElement, IControl, INamed, ISupportInitialize, IVisualBrushInitialize, IRequiresTemplateInSetter
+    public class Control : InputElement, IControl, INamed, ISupportInitialize, IVisualBrushInitialize, ISetterValue
     {
         /// <summary>
         /// Defines the <see cref="FocusAdorner"/> property.
@@ -90,6 +91,13 @@ namespace Avalonia.Controls
         /// <inheritdoc/>
         bool IDataTemplateHost.IsDataTemplatesInitialized => _dataTemplates != null;
 
+        /// <inheritdoc/>
+        void ISetterValue.Initialize(ISetter setter)
+        {
+            throw new InvalidOperationException(
+                "Cannot use a control as a Setter value. Wrap the control in a <Template>.");
+        }
+
         /// <inheritdoc/>
         void IVisualBrushInitialize.EnsureInitialized()
         {
diff --git a/src/Avalonia.Styling/Styling/IRequiresTemplateInSetter.cs b/src/Avalonia.Styling/Styling/IRequiresTemplateInSetter.cs
deleted file mode 100644
index 2d562b78d9..0000000000
--- a/src/Avalonia.Styling/Styling/IRequiresTemplateInSetter.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-namespace Avalonia.Styling
-{
-    /// <summary>
-    /// This is an interface for advanced scenarios to assist users in correct style development.
-    /// You as a user will not need to use this interface directly.
-    /// </summary>
-    public interface IRequiresTemplateInSetter
-    {
-    }
-}
diff --git a/src/Avalonia.Styling/Styling/ISetterValue.cs b/src/Avalonia.Styling/Styling/ISetterValue.cs
new file mode 100644
index 0000000000..63c544cf7d
--- /dev/null
+++ b/src/Avalonia.Styling/Styling/ISetterValue.cs
@@ -0,0 +1,13 @@
+namespace Avalonia.Styling
+{
+    /// <summary>
+    /// Customizes the behavior of a class when added as a value to an <see cref="ISetter"/>.
+    /// </summary>
+    public interface ISetterValue
+    {
+        /// <summary>
+        /// Notifies that the object has been added as a setter value.
+        /// </summary>
+        void Initialize(ISetter setter);
+    }
+}
diff --git a/src/Avalonia.Styling/Styling/Setter.cs b/src/Avalonia.Styling/Styling/Setter.cs
index cfe17a4291..3702259f35 100644
--- a/src/Avalonia.Styling/Styling/Setter.cs
+++ b/src/Avalonia.Styling/Styling/Setter.cs
@@ -65,13 +65,7 @@ namespace Avalonia.Styling
 
             set
             {
-                if (value is IRequiresTemplateInSetter)
-                {
-                    throw new ArgumentException(
-                        "Cannot assign a control to Setter.Value. Wrap the control in a <Template>.",
-                        nameof(value));
-                }
-
+                (value as ISetterValue)?.Initialize(this);
                 _value = value;
             }
         }
diff --git a/src/Markup/Avalonia.Markup/Data/TemplateBinding.cs b/src/Markup/Avalonia.Markup/Data/TemplateBinding.cs
index fab9bdbf55..e64efd9df9 100644
--- a/src/Markup/Avalonia.Markup/Data/TemplateBinding.cs
+++ b/src/Markup/Avalonia.Markup/Data/TemplateBinding.cs
@@ -3,6 +3,7 @@ using System.Globalization;
 using System.Reactive.Subjects;
 using Avalonia.Data.Converters;
 using Avalonia.Reactive;
+using Avalonia.Styling;
 
 namespace Avalonia.Data
 {
@@ -12,8 +13,10 @@ namespace Avalonia.Data
     public class TemplateBinding : SingleSubscriberObservableBase<object>,
         IBinding,
         IDescription,
-        ISubject<object>
+        ISubject<object>,
+        ISetterValue
     {
+        private bool _isSetterValue;
         private IStyledElement _target;
         private Type _targetType;
 
@@ -35,10 +38,11 @@ namespace Avalonia.Data
         {
             // Usually each `TemplateBinding` will only be instantiated once; in this case we can
             // use the `TemplateBinding` object itself as the instanced binding in order to save
-            // allocating a new object. If the binding *is* instantiated more than once (which can
-            // happen if it appears in a `Setter` for example, then just make a clone and instantiate
-            // that.
-            if (_target == null)
+            // allocating a new object.
+            //
+            // If the binding appears in a `Setter`, then make a clone and instantiate that because
+            // because the setter can outlive the control and cause a leak.
+            if (_target == null && !_isSetterValue)
             {
                 _target = (IStyledElement)target;
                 _targetType = targetProperty?.PropertyType;
@@ -106,6 +110,9 @@ namespace Avalonia.Data
             }
         }
 
+        /// <inheritdoc/>
+        void ISetterValue.Initialize(ISetter setter) => _isSetterValue = true;
+
         protected override void Subscribed()
         {
             TemplatedParentChanged();
diff --git a/tests/Avalonia.Styling.UnitTests/SetterTests.cs b/tests/Avalonia.Styling.UnitTests/SetterTests.cs
index 7c1623cf21..898606881a 100644
--- a/tests/Avalonia.Styling.UnitTests/SetterTests.cs
+++ b/tests/Avalonia.Styling.UnitTests/SetterTests.cs
@@ -1,17 +1,15 @@
 // 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 System.Globalization;
 using System.Reactive.Subjects;
-using Moq;
 using Avalonia.Controls;
-using Avalonia.Data;
-using Xunit;
-using System;
 using Avalonia.Controls.Templates;
-using Avalonia.Markup.Data;
-using Avalonia.Markup;
-using System.Globalization;
+using Avalonia.Data;
 using Avalonia.Data.Converters;
+using Moq;
+using Xunit;
 
 namespace Avalonia.Styling.UnitTests
 {
@@ -22,7 +20,7 @@ namespace Avalonia.Styling.UnitTests
         {
             var target = new Setter();
 
-            Assert.Throws<ArgumentException>(() => target.Value = new Border());
+            Assert.Throws<InvalidOperationException>(() => target.Value = new Border());
         }
 
         [Fact]

From 80cd6632bd7ea8b6d3cb4a0e76c4fc3aab3bc3bb Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Thu, 25 Apr 2019 23:10:46 +0100
Subject: [PATCH 03/20] close menu if the toplevel menu item is clicked and its
 already opened.

makes behavior consistent with wpf.
---
 .../Platform/DefaultMenuInteractionHandler.cs       | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs b/src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs
index 942104d61b..0badd918cc 100644
--- a/src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs
+++ b/src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs
@@ -336,7 +336,18 @@ namespace Avalonia.Controls.Platform
 
             if (e.MouseButton == MouseButton.Left && item?.HasSubMenu == true)
             {
-                Open(item, false);
+                if (item.IsSubMenuOpen)
+                {
+                    if (item.Parent is Menu)
+                    {
+                        CloseMenu(item);
+                    }
+                }
+                else
+                {
+                    Open(item, false);
+                }
+
                 e.Handled = true;
             }
         }

From d055e9e4b94b8a63d8b4da34396cae434606466d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Pedro?= <jpedrolmail@gmail.com>
Date: Sat, 27 Apr 2019 23:57:52 +0100
Subject: [PATCH 04/20] Removed unused field. Removed unused usings. Whitespace
 cleanup.

---
 src/Avalonia.Visuals/Rendering/DeferredRenderer.cs | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs b/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs
index 5293e1b978..5d1c66f872 100644
--- a/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs
+++ b/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs
@@ -5,7 +5,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading;
 using Avalonia.Media;
 using Avalonia.Media.Immutable;
 using Avalonia.Platform;
@@ -13,7 +12,6 @@ using Avalonia.Rendering.SceneGraph;
 using Avalonia.Threading;
 using Avalonia.Utilities;
 using Avalonia.VisualTree;
-using System.Threading.Tasks;
 
 namespace Avalonia.Rendering
 {
@@ -33,7 +31,6 @@ namespace Avalonia.Rendering
         private volatile IRef<Scene> _scene;
         private DirtyVisuals _dirty;
         private IRef<IRenderTargetBitmapImpl> _overlay;
-        private object _rendering = new object();
         private int _lastSceneId = -1;
         private DisplayDirtyRects _dirtyRectsDisplay = new DisplayDirtyRects();
         private IRef<IDrawOperation> _currentDraw;
@@ -267,7 +264,7 @@ namespace Avalonia.Rendering
                                     RenderOverlay(scene.Item, GetContext());
                                 if (updated || forceComposite || overlay)
                                     RenderComposite(scene.Item, GetContext());
-                             }
+                            }
                         }
                     }
                     finally
@@ -321,15 +318,15 @@ namespace Avalonia.Rendering
                         var (rs, _) = UpdateRenderLayersAndConsumeSceneIfNeeded(contextFactory, true);
                         return (rs, true);
                     }
-                    
+
                     // Indicate that we have updated the layers
                     return (sceneRef.Clone(), true);
                 }
-                
+
                 // Just return scene, layers weren't updated
                 return (sceneRef.Clone(), false);
             }
-            
+
         }
 
 
@@ -456,7 +453,7 @@ namespace Avalonia.Rendering
         private void RenderComposite(Scene scene, IDrawingContextImpl context)
         {
             context.Clear(Colors.Transparent);
-            
+
             var clientRect = new Rect(scene.Size);
 
             foreach (var layer in scene.Layers)

From f8cf268f0e86e32c6c7bb700400a24141ce3beb5 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Wed, 1 May 2019 12:02:12 +0200
Subject: [PATCH 05/20] Added unit test for toplevel menu close.

Added unit test for previous commit, and also tweaked code a little bit to use `IsTopLevel` instead of trying to cast the parent menu item.
---
 .../Platform/DefaultMenuInteractionHandler.cs   |  2 +-
 .../DefaultMenuInteractionHandlerTests.cs       | 17 +++++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs b/src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs
index 0badd918cc..73854b9f60 100644
--- a/src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs
+++ b/src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs
@@ -338,7 +338,7 @@ namespace Avalonia.Controls.Platform
             {
                 if (item.IsSubMenuOpen)
                 {
-                    if (item.Parent is Menu)
+                    if (item.IsTopLevel)
                     {
                         CloseMenu(item);
                     }
diff --git a/tests/Avalonia.Controls.UnitTests/Platform/DefaultMenuInteractionHandlerTests.cs b/tests/Avalonia.Controls.UnitTests/Platform/DefaultMenuInteractionHandlerTests.cs
index 87b235dce7..df1846c617 100644
--- a/tests/Avalonia.Controls.UnitTests/Platform/DefaultMenuInteractionHandlerTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Platform/DefaultMenuInteractionHandlerTests.cs
@@ -1,6 +1,7 @@
 using System;
 using Avalonia.Controls.Platform;
 using Avalonia.Input;
+using Avalonia.Interactivity;
 using Moq;
 using Xunit;
 
@@ -110,6 +111,22 @@ namespace Avalonia.Controls.UnitTests.Platform
                 Assert.True(e.Handled);
             }
 
+            [Fact]
+            public void Click_On_Open_TopLevel_Menu_Closes_Menu()
+            {
+                var target = new DefaultMenuInteractionHandler(false);
+                var menu = Mock.Of<IMenu>();
+                var item = Mock.Of<IMenuItem>(x =>
+                    x.IsSubMenuOpen == true &&
+                    x.IsTopLevel == true && 
+                    x.HasSubMenu == true &&
+                    x.Parent == menu);
+                var e = new PointerPressedEventArgs { MouseButton = MouseButton.Left, Source = item };
+
+                target.PointerPressed(item, e);
+                Mock.Get(menu).Verify(x => x.Close());
+            }
+
             [Fact]
             public void PointerEnter_Opens_Item_When_Old_Item_Is_Open()
             {

From d22282c15155b74f04fb2f70351191104e3c7e3a Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Wed, 1 May 2019 14:53:14 +0200
Subject: [PATCH 06/20] Added failing tests for #2470.

---
 .../Data/BindingTests.cs                      | 22 ++++++++++++++
 .../Xaml/BindingTests.cs                      | 29 ++++++++++++++++++-
 2 files changed, 50 insertions(+), 1 deletion(-)

diff --git a/tests/Avalonia.Markup.UnitTests/Data/BindingTests.cs b/tests/Avalonia.Markup.UnitTests/Data/BindingTests.cs
index baa1bca76a..d19accb0ad 100644
--- a/tests/Avalonia.Markup.UnitTests/Data/BindingTests.cs
+++ b/tests/Avalonia.Markup.UnitTests/Data/BindingTests.cs
@@ -100,6 +100,28 @@ namespace Avalonia.Markup.UnitTests.Data
             Assert.Equal("baz", target.Text);
         }
 
+        [Fact]
+        public void OneWayToSource_Binding_Should_React_To_DataContext_Changed()
+        {
+            var target = new TextBlock { Text = "bar" };
+            var binding = new Binding
+            {
+                Path = "Foo",
+                Mode = BindingMode.OneWayToSource,
+            };
+
+            target.Bind(TextBox.TextProperty, binding);
+
+            var source = new Source { Foo = "foo" };
+            target.DataContext = source;
+
+            Assert.Equal("bar", source.Foo);
+            target.Text = "baz";
+            Assert.Equal("baz", source.Foo);
+            source.Foo = "quz";
+            Assert.Equal("baz", target.Text);
+        }
+
         [Fact]
         public void Default_BindingMode_Should_Be_Used()
         {
diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BindingTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BindingTests.cs
index fef9dfb675..14abebcdb5 100644
--- a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BindingTests.cs
+++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/BindingTests.cs
@@ -329,6 +329,33 @@ namespace Avalonia.Markup.Xaml.UnitTests.Xaml
 
                 Assert.Equal("Hello world", textBlock.Text); 
             }
-        } 
+        }
+
+        [Fact]
+        public void Binding_OneWayToSource_Works()
+        {
+            using (UnitTestApplication.Start(TestServices.StyledWindow))
+            {
+                var xaml = @"
+<Window xmlns='https://github.com/avaloniaui'
+        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
+        ShowInTaskbar='{Binding ShowInTaskbar, Mode=OneWayToSource}'>
+</Window>";
+                var loader = new AvaloniaXamlLoader();
+                var window = (Window)loader.Load(xaml);
+                var viewModel = new WindowViewModel();
+
+                window.DataContext = viewModel;
+                window.ApplyTemplate();
+
+                Assert.True(window.ShowInTaskbar);
+                Assert.True(viewModel.ShowInTaskbar);
+            }
+        }
+
+        private class WindowViewModel
+        {
+            public bool ShowInTaskbar { get; set; }
+        }
     }
 }

From 197d7d4904b4767d882c676232cad67ffe3fd566 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Wed, 1 May 2019 14:54:20 +0200
Subject: [PATCH 07/20] Update OneWayToSource binding when DataContext changes.

Fixes #2470
---
 src/Avalonia.Base/Data/BindingOperations.cs         | 6 +++++-
 src/Avalonia.Base/Data/Core/PropertyAccessorNode.cs | 2 +-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/Avalonia.Base/Data/BindingOperations.cs b/src/Avalonia.Base/Data/BindingOperations.cs
index ca148659e6..15de6c4d0d 100644
--- a/src/Avalonia.Base/Data/BindingOperations.cs
+++ b/src/Avalonia.Base/Data/BindingOperations.cs
@@ -65,7 +65,11 @@ namespace Avalonia.Data
                         return Disposable.Empty;
                     }
                 case BindingMode.OneWayToSource:
-                    return target.GetObservable(property).Subscribe(binding.Subject);
+                    return Observable.CombineLatest(
+                        binding.Observable,
+                        target.GetObservable(property),
+                        (_, v) => v)
+                    .Subscribe(x => binding.Subject.OnNext(x));
                 default:
                     throw new ArgumentException("Invalid binding mode.");
             }
diff --git a/src/Avalonia.Base/Data/Core/PropertyAccessorNode.cs b/src/Avalonia.Base/Data/Core/PropertyAccessorNode.cs
index a916142675..df8f46a7d7 100644
--- a/src/Avalonia.Base/Data/Core/PropertyAccessorNode.cs
+++ b/src/Avalonia.Base/Data/Core/PropertyAccessorNode.cs
@@ -59,8 +59,8 @@ namespace Avalonia.Data.Core
                     $"Could not find a matching property accessor for {PropertyName}.");
             }
 
-            accessor.Subscribe(ValueChanged);
             _accessor = accessor;
+            accessor.Subscribe(ValueChanged);
         }
 
         protected override void StopListeningCore()

From 1693fd8d8d2aba0b4b05966bd72d2878d64323be Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Wed, 1 May 2019 20:16:07 +0200
Subject: [PATCH 08/20] Remove unsupported armeabi.

---
 samples/ControlCatalog.Android/ControlCatalog.Android.csproj  | 4 ++--
 .../Avalonia.AndroidTestApplication.csproj                    | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/samples/ControlCatalog.Android/ControlCatalog.Android.csproj b/samples/ControlCatalog.Android/ControlCatalog.Android.csproj
index 272632e7eb..d8f0f39977 100644
--- a/samples/ControlCatalog.Android/ControlCatalog.Android.csproj
+++ b/samples/ControlCatalog.Android/ControlCatalog.Android.csproj
@@ -32,7 +32,7 @@
     <EmbedAssembliesIntoApk>True</EmbedAssembliesIntoApk>
     <BundleAssemblies>False</BundleAssemblies>
     <AndroidCreatePackagePerAbi>False</AndroidCreatePackagePerAbi>
-    <AndroidSupportedAbis>armeabi;armeabi-v7a;x86</AndroidSupportedAbis>
+    <AndroidSupportedAbis>armeabi-v7a;x86</AndroidSupportedAbis>
     <Debugger>Xamarin</Debugger>
     <AndroidEnableMultiDex>False</AndroidEnableMultiDex>
     <AotAssemblies>False</AotAssemblies>
@@ -51,7 +51,7 @@
     <EmbedAssembliesIntoApk>True</EmbedAssembliesIntoApk>
     <BundleAssemblies>False</BundleAssemblies>
     <AndroidCreatePackagePerAbi>False</AndroidCreatePackagePerAbi>
-    <AndroidSupportedAbis>armeabi,armeabi-v7a,x86</AndroidSupportedAbis>
+    <AndroidSupportedAbis>armeabi-v7a,x86</AndroidSupportedAbis>
     <Debugger>Xamarin</Debugger>
     <AotAssemblies>False</AotAssemblies>
     <EnableLLVM>False</EnableLLVM>
diff --git a/src/Android/Avalonia.AndroidTestApplication/Avalonia.AndroidTestApplication.csproj b/src/Android/Avalonia.AndroidTestApplication/Avalonia.AndroidTestApplication.csproj
index b493fd1ef2..c2c0cd4301 100644
--- a/src/Android/Avalonia.AndroidTestApplication/Avalonia.AndroidTestApplication.csproj
+++ b/src/Android/Avalonia.AndroidTestApplication/Avalonia.AndroidTestApplication.csproj
@@ -32,7 +32,7 @@
     <EmbedAssembliesIntoApk>True</EmbedAssembliesIntoApk>
     <BundleAssemblies>False</BundleAssemblies>
     <AndroidCreatePackagePerAbi>False</AndroidCreatePackagePerAbi>
-    <AndroidSupportedAbis>armeabi;armeabi-v7a;x86</AndroidSupportedAbis>
+    <AndroidSupportedAbis>armeabi-v7a;x86</AndroidSupportedAbis>
     <Debugger>Xamarin</Debugger>
     <AndroidEnableMultiDex>False</AndroidEnableMultiDex>
     <DevInstrumentationEnabled>True</DevInstrumentationEnabled>
@@ -52,7 +52,7 @@
     <EmbedAssembliesIntoApk>True</EmbedAssembliesIntoApk>
     <BundleAssemblies>False</BundleAssemblies>
     <AndroidCreatePackagePerAbi>False</AndroidCreatePackagePerAbi>
-    <AndroidSupportedAbis>armeabi,armeabi-v7a,x86</AndroidSupportedAbis>
+    <AndroidSupportedAbis>armeabi-v7a,x86</AndroidSupportedAbis>
     <Debugger>Xamarin</Debugger>
     <AotAssemblies>False</AotAssemblies>
     <EnableLLVM>False</EnableLLVM>

From 9a60d77e635c3cf1b94910dd0a28942d35ca1a4b Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Wed, 1 May 2019 20:33:47 +0200
Subject: [PATCH 09/20] Don't import SkiaSharp.props into WindowsInteropTest.

Fixes the `"C:\Users\[user]\.nuget\packages\SkiaSharp\1.68.0\build\net45\SkiaSharp.dll.config" because it was not found.` error.
---
 samples/interop/WindowsInteropTest/WindowsInteropTest.csproj | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/samples/interop/WindowsInteropTest/WindowsInteropTest.csproj b/samples/interop/WindowsInteropTest/WindowsInteropTest.csproj
index 33c7b85f06..9d21e4ff6b 100644
--- a/samples/interop/WindowsInteropTest/WindowsInteropTest.csproj
+++ b/samples/interop/WindowsInteropTest/WindowsInteropTest.csproj
@@ -185,6 +185,5 @@
   </ItemGroup>
   <Import Project="..\..\..\build\Rx.props" />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Import Project="..\..\..\build\SkiaSharp.props" />
   <Import Project="..\..\..\build\LegacyProject.targets" />
-</Project>
\ No newline at end of file
+</Project>

From 9650c7f9e39a3265ff4cde7c0b486ce6a8264f35 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Wed, 1 May 2019 20:35:07 +0200
Subject: [PATCH 10/20] Call UseDataGrid in WindowInteropTest.

The `ControlCatalog` that is being embedded requires it.
---
 samples/interop/WindowsInteropTest/Program.cs               | 2 +-
 .../interop/WindowsInteropTest/WindowsInteropTest.csproj    | 6 +++++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/samples/interop/WindowsInteropTest/Program.cs b/samples/interop/WindowsInteropTest/Program.cs
index fac06d74b0..9f005b942d 100644
--- a/samples/interop/WindowsInteropTest/Program.cs
+++ b/samples/interop/WindowsInteropTest/Program.cs
@@ -15,7 +15,7 @@ namespace WindowsInteropTest
         {
             System.Windows.Forms.Application.EnableVisualStyles();
             System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(false);
-            AppBuilder.Configure<App>().UseWin32().UseDirect2D1().SetupWithoutStarting();
+            AppBuilder.Configure<App>().UseWin32().UseDirect2D1().UseDataGrid().SetupWithoutStarting();
             System.Windows.Forms.Application.Run(new SelectorForm());
         }
     }
diff --git a/samples/interop/WindowsInteropTest/WindowsInteropTest.csproj b/samples/interop/WindowsInteropTest/WindowsInteropTest.csproj
index 9d21e4ff6b..c067d38595 100644
--- a/samples/interop/WindowsInteropTest/WindowsInteropTest.csproj
+++ b/samples/interop/WindowsInteropTest/WindowsInteropTest.csproj
@@ -104,6 +104,10 @@
       <Project>{b09b78d8-9b26-48b0-9149-d64a2f120f3f}</Project>
       <Name>Avalonia.Base</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\src\Avalonia.Controls.DataGrid\Avalonia.Controls.DataGrid.csproj">
+      <Project>{3278f3a9-9509-4a3f-a15b-bdc8b5bff632}</Project>
+      <Name>Avalonia.Controls.DataGrid</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\..\src\Avalonia.Controls\Avalonia.Controls.csproj">
       <Project>{d2221c82-4a25-4583-9b43-d791e3f6820c}</Project>
       <Name>Avalonia.Controls</Name>
@@ -186,4 +190,4 @@
   <Import Project="..\..\..\build\Rx.props" />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="..\..\..\build\LegacyProject.targets" />
-</Project>
+</Project>
\ No newline at end of file

From d19f159932490fa65b5cd277b50f50ff5cb3bcd4 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 2 May 2019 16:14:50 +0200
Subject: [PATCH 11/20] Added failing tests for #2432.

---
 .../Presenters/CarouselPresenterTests.cs      | 107 ++++++++++++++++++
 1 file changed, 107 insertions(+)

diff --git a/tests/Avalonia.Controls.UnitTests/Presenters/CarouselPresenterTests.cs b/tests/Avalonia.Controls.UnitTests/Presenters/CarouselPresenterTests.cs
index c5ff64b0e3..828f96b806 100644
--- a/tests/Avalonia.Controls.UnitTests/Presenters/CarouselPresenterTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Presenters/CarouselPresenterTests.cs
@@ -193,6 +193,113 @@ namespace Avalonia.Controls.UnitTests.Presenters
             Assert.Empty(target.Panel.Children);            
         }
 
+        [Fact]
+        public void Should_Handle_Inserting_Items_At_SelectedItem()
+        {
+            ObservableCollection<string> items = new ObservableCollection<string>
+            {
+                "item1",
+                "item2",
+                "item3",
+            };
+
+            var target = new CarouselPresenter
+            {
+                Items = items,
+                SelectedIndex = 0,
+                IsVirtualized = false,
+            };
+
+            target.ApplyTemplate();
+            target.SelectedIndex = 1;
+
+            items.Insert(1, "item1a");
+
+            var containers = target.ItemContainerGenerator.Containers.Select(x => (x.Index, (string)x.Item));
+
+            Assert.Equal(
+                new[]
+                {
+                    (0, "item1"),
+                    (1, "item1a"),
+                    (2, "item2"),
+                },
+                containers);
+
+            var visibleContainer = (ContentPresenter)target.Panel.Children.Single(x => x.IsVisible);
+            Assert.Equal("item1a", visibleContainer.Content);
+        }
+
+        [Fact]
+        public void Should_Handle_Inserting_Items_Before_SelectedItem()
+        {
+            ObservableCollection<string> items = new ObservableCollection<string>
+            {
+                "item1",
+                "item2",
+                "item3",
+            };
+
+            var target = new CarouselPresenter
+            {
+                Items = items,
+                SelectedIndex = 0,
+                IsVirtualized = false,
+            };
+
+            target.ApplyTemplate();
+            target.SelectedIndex = 2;
+
+            items.Insert(1, "item1a");
+
+            var actual = target.ItemContainerGenerator.Containers.Select(x => (x.Index, (string)x.Item));
+
+            Assert.Equal(
+                new[]
+                {
+                    (0, "item1"),
+                    (3, "item3"),
+                },
+                actual);
+
+            var visibleContainer = (ContentPresenter)target.Panel.Children.Single(x => x.IsVisible);
+            Assert.Equal("item3", visibleContainer.Content);
+        }
+
+        [Fact]
+        public void Should_Handle_Inserting_Items_After_SelectedItem()
+        {
+            ObservableCollection<string> items = new ObservableCollection<string>
+            {
+                "item1",
+                "item2",
+                "item3",
+            };
+
+            var target = new CarouselPresenter
+            {
+                Items = items,
+                SelectedIndex = 0,
+                IsVirtualized = false,
+            };
+
+            target.ApplyTemplate();
+            target.SelectedIndex = 1;
+            target.SelectedIndex = 0;
+
+            items.Insert(1, "item1a");
+
+            var actual = target.ItemContainerGenerator.Containers.Select(x => (x.Index, (string)x.Item));
+
+            Assert.Equal(
+                new[]
+                {
+                    (0, "item1"),
+                    (2, "item2"),
+                },
+                actual);
+        }
+
         private class TestItem : ContentControl
         {
         }

From 76c3d0c03d9b2457cc312db577258f3c9a93013d Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 2 May 2019 16:16:29 +0200
Subject: [PATCH 12/20] Handle item insertion in CarouselPresenter.

Fixes #2432.
---
 .../Presenters/CarouselPresenter.cs           | 25 ++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/src/Avalonia.Controls/Presenters/CarouselPresenter.cs b/src/Avalonia.Controls/Presenters/CarouselPresenter.cs
index ba2c7c91d8..f9f8d58430 100644
--- a/src/Avalonia.Controls/Presenters/CarouselPresenter.cs
+++ b/src/Avalonia.Controls/Presenters/CarouselPresenter.cs
@@ -38,7 +38,6 @@ namespace Avalonia.Controls.Presenters
             Carousel.PageTransitionProperty.AddOwner<CarouselPresenter>();
 
         private int _selectedIndex = -1;
-       // private Task _current;
         private Task _currentTransition;
         private int _queuedTransitionIndex = -1;
 
@@ -105,12 +104,33 @@ namespace Avalonia.Controls.Presenters
         /// <inheritdoc/>
         protected override void ItemsChanged(NotifyCollectionChangedEventArgs e)
         {
+            var generator = ItemContainerGenerator;
+
             switch (e.Action)
             {
+                case NotifyCollectionChangedAction.Add:
+                    var end = e.NewStartingIndex + e.NewItems.Count;
+
+                    if (end < Items.Count())
+                    {
+                        generator.InsertSpace(e.NewStartingIndex, e.NewItems.Count);
+                    }
+
+                    if (SelectedIndex >= e.NewStartingIndex && SelectedIndex < end)
+                    {
+                        var newItem = GetOrCreateContainer(SelectedIndex);
+
+                        foreach (var control in Panel.Children)
+                        {
+                            control.IsVisible = control == newItem;
+                        }
+                    }
+
+                    break;
+
                 case NotifyCollectionChangedAction.Remove:
                     if (!IsVirtualized)
                     {
-                        var generator = ItemContainerGenerator;
                         var containers = generator.RemoveRange(e.OldStartingIndex, e.OldItems.Count);
                         Panel.Children.RemoveAll(containers.Select(x => x.ContainerControl));
 
@@ -122,7 +142,6 @@ namespace Avalonia.Controls.Presenters
 
                 case NotifyCollectionChangedAction.Reset:
                     {
-                        var generator = ItemContainerGenerator;
                         var containers = generator.Containers.ToList();
                         generator.Clear();
                         Panel.Children.RemoveAll(containers.Select(x => x.ContainerControl));

From 5745b72222af8e359ae45725d32c348f0c95d627 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 3 May 2019 11:02:10 +0200
Subject: [PATCH 13/20] Started refactoring CarouselPresenter.

Make it react correctly to changes in the source collection. Fixes #2432.
---
 .../Presenters/CarouselPresenter.cs           | 121 +--
 .../Presenters/ItemContainerSync.cs           | 125 +++
 .../Presenters/ItemVirtualizerNone.cs         |  48 +-
 .../Presenters/ItemsPresenterBase.cs          |   9 +-
 .../CarouselTests.cs                          |  38 +-
 .../Presenters/CarouselPresenterTests.cs      | 802 +++++++++++++-----
 6 files changed, 818 insertions(+), 325 deletions(-)
 create mode 100644 src/Avalonia.Controls/Presenters/ItemContainerSync.cs

diff --git a/src/Avalonia.Controls/Presenters/CarouselPresenter.cs b/src/Avalonia.Controls/Presenters/CarouselPresenter.cs
index f9f8d58430..bdc4d29400 100644
--- a/src/Avalonia.Controls/Presenters/CarouselPresenter.cs
+++ b/src/Avalonia.Controls/Presenters/CarouselPresenter.cs
@@ -46,6 +46,7 @@ namespace Avalonia.Controls.Presenters
         /// </summary>
         static CarouselPresenter()
         {
+            IsVirtualizedProperty.Changed.AddClassHandler<CarouselPresenter>(x => x.IsVirtualizedChanged);
             SelectedIndexProperty.Changed.AddClassHandler<CarouselPresenter>(x => x.SelectedIndexChanged);
         }
 
@@ -93,78 +94,72 @@ namespace Avalonia.Controls.Presenters
             set { SetValue(PageTransitionProperty, value); }
         }
 
-        /// <inheritdoc/>
         protected override void PanelCreated(IPanel panel)
         {
-#pragma warning disable 4014
-            MoveToPage(-1, SelectedIndex);
-#pragma warning restore 4014
+            base.PanelCreated(panel);
         }
 
         /// <inheritdoc/>
         protected override void ItemsChanged(NotifyCollectionChangedEventArgs e)
         {
-            var generator = ItemContainerGenerator;
-
-            switch (e.Action)
+            if (!IsVirtualized)
             {
-                case NotifyCollectionChangedAction.Add:
-                    var end = e.NewStartingIndex + e.NewItems.Count;
-
-                    if (end < Items.Count())
-                    {
-                        generator.InsertSpace(e.NewStartingIndex, e.NewItems.Count);
-                    }
+                base.ItemsChanged(e);
 
-                    if (SelectedIndex >= e.NewStartingIndex && SelectedIndex < end)
-                    {
-                        var newItem = GetOrCreateContainer(SelectedIndex);
+                if (Items == null || SelectedIndex >= Items.Count())
+                {
+                    SelectedIndex = Items.Count() - 1;
+                }
 
-                        foreach (var control in Panel.Children)
+                foreach (var c in ItemContainerGenerator.Containers)
+                {
+                    c.ContainerControl.IsVisible = c.Index == SelectedIndex;
+                }
+            }
+            else if (SelectedIndex != -1 && Panel != null)
+            {
+                switch (e.Action)
+                {
+                    case NotifyCollectionChangedAction.Add:
+                        if (e.NewStartingIndex > SelectedIndex)
                         {
-                            control.IsVisible = control == newItem;
+                            return;
                         }
-                    }
-
-                    break;
-
-                case NotifyCollectionChangedAction.Remove:
-                    if (!IsVirtualized)
-                    {
-                        var containers = generator.RemoveRange(e.OldStartingIndex, e.OldItems.Count);
-                        Panel.Children.RemoveAll(containers.Select(x => x.ContainerControl));
-
-#pragma warning disable 4014
-                        MoveToPage(-1, SelectedIndex);
-#pragma warning restore 4014
-                    }
-                    break;
+                        break;
+                    case NotifyCollectionChangedAction.Remove:
+                        if (e.OldStartingIndex > SelectedIndex)
+                        {
+                            return;
+                        }
+                        break;
+                    case NotifyCollectionChangedAction.Replace:
+                        if (e.OldStartingIndex > SelectedIndex ||
+                            e.OldStartingIndex + e.OldItems.Count - 1 < SelectedIndex)
+                        {
+                            return;
+                        }
+                        break;
+                    case NotifyCollectionChangedAction.Move:
+                        if (e.OldStartingIndex > SelectedIndex &&
+                            e.NewStartingIndex > SelectedIndex)
+                        {
+                            return;
+                        }
+                        break;
+                }
 
-                case NotifyCollectionChangedAction.Reset:
-                    {
-                        var containers = generator.Containers.ToList();
-                        generator.Clear();
-                        Panel.Children.RemoveAll(containers.Select(x => x.ContainerControl));
+                if (Items == null || SelectedIndex >= Items.Count())
+                {
+                    SelectedIndex = Items.Count() - 1;
+                }
 
-#pragma warning disable 4014
-                        var newIndex = SelectedIndex;
+                Panel.Children.Clear();
+                ItemContainerGenerator.Clear();
 
-                        if(SelectedIndex < 0)
-                        {
-                            if(Items != null && Items.Count() > 0)
-                            {
-                                newIndex = 0;
-                            }
-                            else
-                            {
-                                newIndex = -1;
-                            }
-                        }
-                        
-                        MoveToPage(-1, newIndex);
-#pragma warning restore 4014
-                    }
-                    break;     
+                if (SelectedIndex != -1)
+                {
+                    GetOrCreateContainer(SelectedIndex);
+                }
             }
         }
 
@@ -231,6 +226,18 @@ namespace Avalonia.Controls.Presenters
             return container;
         }
 
+        /// <summary>
+        /// Called when the <see cref="IsVirtualized"/> property changes.
+        /// </summary>
+        /// <param name="e">The event args.</param>
+        private void IsVirtualizedChanged(AvaloniaPropertyChangedEventArgs e)
+        {
+            if (Panel != null)
+            {
+                ItemsChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
+            }
+        }
+
         /// <summary>
         /// Called when the <see cref="SelectedIndex"/> property changes.
         /// </summary>
diff --git a/src/Avalonia.Controls/Presenters/ItemContainerSync.cs b/src/Avalonia.Controls/Presenters/ItemContainerSync.cs
new file mode 100644
index 0000000000..035d404dec
--- /dev/null
+++ b/src/Avalonia.Controls/Presenters/ItemContainerSync.cs
@@ -0,0 +1,125 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using Avalonia.Controls.Generators;
+using Avalonia.Controls.Utils;
+
+namespace Avalonia.Controls.Presenters
+{
+    internal static class ItemContainerSync
+    {
+        public static void ItemsChanged(
+            ItemsPresenterBase owner,
+            IEnumerable items,
+            NotifyCollectionChangedEventArgs e)
+        {
+            var generator = owner.ItemContainerGenerator;
+            var panel = owner.Panel;
+
+            if (panel == null)
+            {
+                return;
+            }
+
+            void Add()
+            {
+                if (e.NewStartingIndex + e.NewItems.Count < items.Count())
+                {
+                    generator.InsertSpace(e.NewStartingIndex, e.NewItems.Count);
+                }
+
+                AddContainers(owner, e.NewStartingIndex, e.NewItems);
+            }
+
+            void Remove()
+            {
+                RemoveContainers(panel, generator.RemoveRange(e.OldStartingIndex, e.OldItems.Count));
+            }
+
+            switch (e.Action)
+            {
+                case NotifyCollectionChangedAction.Add:
+                    Add();
+                    break;
+
+                case NotifyCollectionChangedAction.Remove:
+                    Remove();
+                    break;
+
+                case NotifyCollectionChangedAction.Replace:
+                    RemoveContainers(panel, generator.Dematerialize(e.OldStartingIndex, e.OldItems.Count));
+                    var containers = AddContainers(owner, e.NewStartingIndex, e.NewItems);
+
+                    var i = e.NewStartingIndex;
+
+                    foreach (var container in containers)
+                    {
+                        panel.Children[i++] = container.ContainerControl;
+                    }
+
+                    break;
+
+                case NotifyCollectionChangedAction.Move:
+                    Remove();
+                    Add();
+                    break;
+
+                case NotifyCollectionChangedAction.Reset:
+                    RemoveContainers(panel, generator.Clear());
+
+                    if (items != null)
+                    {
+                        AddContainers(owner, 0, items);
+                    }
+
+                    break;
+            }
+        }
+
+        private static IList<ItemContainerInfo> AddContainers(
+            ItemsPresenterBase owner,
+            int index,
+            IEnumerable items)
+        {
+            var generator = owner.ItemContainerGenerator;
+            var result = new List<ItemContainerInfo>();
+            var panel = owner.Panel;
+
+            foreach (var item in items)
+            {
+                var i = generator.Materialize(index++, item, owner.MemberSelector);
+
+                if (i.ContainerControl != null)
+                {
+                    if (i.Index < panel.Children.Count)
+                    {
+                        // TODO: This will insert at the wrong place when there are null items.
+                        panel.Children.Insert(i.Index, i.ContainerControl);
+                    }
+                    else
+                    {
+                        panel.Children.Add(i.ContainerControl);
+                    }
+                }
+
+                result.Add(i);
+            }
+
+            return result;
+        }
+
+        private static void RemoveContainers(
+            IPanel panel,
+            IEnumerable<ItemContainerInfo> items)
+        {
+            foreach (var i in items)
+            {
+                if (i.ContainerControl != null)
+                {
+                    panel.Children.Remove(i.ContainerControl);
+                }
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Controls/Presenters/ItemVirtualizerNone.cs b/src/Avalonia.Controls/Presenters/ItemVirtualizerNone.cs
index 8947b30e63..413855bcc6 100644
--- a/src/Avalonia.Controls/Presenters/ItemVirtualizerNone.cs
+++ b/src/Avalonia.Controls/Presenters/ItemVirtualizerNone.cs
@@ -60,53 +60,7 @@ namespace Avalonia.Controls.Presenters
         public override void ItemsChanged(IEnumerable items, NotifyCollectionChangedEventArgs e)
         {
             base.ItemsChanged(items, e);
-
-            var generator = Owner.ItemContainerGenerator;
-            var panel = Owner.Panel;
-
-            switch (e.Action)
-            {
-                case NotifyCollectionChangedAction.Add:
-                    if (e.NewStartingIndex + e.NewItems.Count < Items.Count())
-                    {
-                        generator.InsertSpace(e.NewStartingIndex, e.NewItems.Count);
-                    }
-
-                    AddContainers(e.NewStartingIndex, e.NewItems);
-                    break;
-
-                case NotifyCollectionChangedAction.Remove:
-                    RemoveContainers(generator.RemoveRange(e.OldStartingIndex, e.OldItems.Count));
-                    break;
-
-                case NotifyCollectionChangedAction.Replace:
-                    RemoveContainers(generator.Dematerialize(e.OldStartingIndex, e.OldItems.Count));
-                    var containers = AddContainers(e.NewStartingIndex, e.NewItems);
-
-                    var i = e.NewStartingIndex;
-
-                    foreach (var container in containers)
-                    {
-                        panel.Children[i++] = container.ContainerControl;
-                    }
-
-                    break;
-
-                case NotifyCollectionChangedAction.Move:
-                    // TODO: Handle move in a more efficient manner. At the moment we just
-                    // drop through to Reset to recreate all the containers.
-
-                case NotifyCollectionChangedAction.Reset:
-                    RemoveContainers(generator.Clear());
-
-                    if (Items != null)
-                    {
-                        AddContainers(0, Items);
-                    }
-
-                    break;
-            }
-
+            ItemContainerSync.ItemsChanged(Owner, items, e);
             Owner.InvalidateMeasure();
         }
 
diff --git a/src/Avalonia.Controls/Presenters/ItemsPresenterBase.cs b/src/Avalonia.Controls/Presenters/ItemsPresenterBase.cs
index e9dc75a236..b4b792139d 100644
--- a/src/Avalonia.Controls/Presenters/ItemsPresenterBase.cs
+++ b/src/Avalonia.Controls/Presenters/ItemsPresenterBase.cs
@@ -7,6 +7,7 @@ using System.Collections.Specialized;
 using Avalonia.Collections;
 using Avalonia.Controls.Generators;
 using Avalonia.Controls.Templates;
+using Avalonia.Controls.Utils;
 using Avalonia.Styling;
 
 namespace Avalonia.Controls.Presenters
@@ -205,7 +206,13 @@ namespace Avalonia.Controls.Presenters
         /// has been set, the items collection has been modified, or the panel has been created.
         /// </summary>
         /// <param name="e">A description of the change.</param>
-        protected abstract void ItemsChanged(NotifyCollectionChangedEventArgs e);
+        /// <remarks>
+        /// The panel is guaranteed to be created when this method is called.
+        /// </remarks>
+        protected virtual void ItemsChanged(NotifyCollectionChangedEventArgs e)
+        {
+            ItemContainerSync.ItemsChanged(this, Items, e);
+        }
 
         /// <summary>
         /// Creates the <see cref="Panel"/> when <see cref="ApplyTemplate"/> is called for the first
diff --git a/tests/Avalonia.Controls.UnitTests/CarouselTests.cs b/tests/Avalonia.Controls.UnitTests/CarouselTests.cs
index f36e5864f6..2070b4b66a 100644
--- a/tests/Avalonia.Controls.UnitTests/CarouselTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/CarouselTests.cs
@@ -76,25 +76,6 @@ namespace Avalonia.Controls.UnitTests
             Assert.Single(target.ItemContainerGenerator.Containers);
         }
 
-        [Fact]
-        public void Should_Not_Remove_NonCurrent_Page_When_IsVirtualized_False()
-        {
-            var target = new Carousel
-            {
-                Template = new FuncControlTemplate<Carousel>(CreateTemplate),
-                Items = new[] { "foo", "bar" },
-                IsVirtualized = false,
-                SelectedIndex = 0,
-            };
-
-            target.ApplyTemplate();
-            target.Presenter.ApplyTemplate();
-
-            Assert.Single(target.ItemContainerGenerator.Containers);
-            target.SelectedIndex = 1;
-            Assert.Equal(2, target.ItemContainerGenerator.Containers.Count());
-        }
-
         [Fact]
         public void Selected_Item_Changes_To_First_Item_When_Items_Property_Changes()
         {
@@ -115,9 +96,9 @@ namespace Avalonia.Controls.UnitTests
             target.ApplyTemplate();
             target.Presenter.ApplyTemplate();
 
-            Assert.Single(target.GetLogicalChildren());
+            Assert.Equal(3, target.GetLogicalChildren().Count());
 
-            var child = target.GetLogicalChildren().Single();
+            var child = target.GetLogicalChildren().First();
 
             Assert.IsType<TextBlock>(child);
             Assert.Equal("Foo", ((TextBlock)child).Text);
@@ -127,7 +108,7 @@ namespace Avalonia.Controls.UnitTests
 
             target.Items = newItems;
 
-            child = target.GetLogicalChildren().Single();
+            child = target.GetLogicalChildren().First();
 
             Assert.IsType<TextBlock>(child);
             Assert.Equal("Bar", ((TextBlock)child).Text);
@@ -146,7 +127,8 @@ namespace Avalonia.Controls.UnitTests
             var target = new Carousel
             {
                 Template = new FuncControlTemplate<Carousel>(CreateTemplate),
-                Items = items
+                Items = items,
+                IsVirtualized = true,
             };
 
             target.ApplyTemplate();
@@ -190,9 +172,9 @@ namespace Avalonia.Controls.UnitTests
             target.ApplyTemplate();
             target.Presenter.ApplyTemplate();
 
-            Assert.Single(target.GetLogicalChildren());
+            Assert.Equal(3, target.GetLogicalChildren().Count());
 
-            var child = target.GetLogicalChildren().Single();
+            var child = target.GetLogicalChildren().First();
 
             Assert.IsType<TextBlock>(child);
             Assert.Equal("Foo", ((TextBlock)child).Text);
@@ -254,16 +236,16 @@ namespace Avalonia.Controls.UnitTests
             target.ApplyTemplate();
             target.Presenter.ApplyTemplate();
 
-            Assert.Single(target.GetLogicalChildren());
+            Assert.Equal(3, target.GetLogicalChildren().Count());
 
-            var child = target.GetLogicalChildren().Single();
+            var child = target.GetLogicalChildren().First();
 
             Assert.IsType<TextBlock>(child);
             Assert.Equal("Foo", ((TextBlock)child).Text);
 
             items.RemoveAt(0);
 
-            child = target.GetLogicalChildren().Single();
+            child = target.GetLogicalChildren().First();
 
             Assert.IsType<TextBlock>(child);
             Assert.Equal("Bar", ((TextBlock)child).Text);
diff --git a/tests/Avalonia.Controls.UnitTests/Presenters/CarouselPresenterTests.cs b/tests/Avalonia.Controls.UnitTests/Presenters/CarouselPresenterTests.cs
index 828f96b806..2cc9965740 100644
--- a/tests/Avalonia.Controls.UnitTests/Presenters/CarouselPresenterTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/Presenters/CarouselPresenterTests.cs
@@ -8,6 +8,7 @@ using Avalonia.Controls.Presenters;
 using Avalonia.Controls.Templates;
 using Xunit;
 using System.Collections.ObjectModel;
+using System.Collections;
 
 namespace Avalonia.Controls.UnitTests.Presenters
 {
@@ -49,255 +50,672 @@ namespace Avalonia.Controls.UnitTests.Presenters
             Assert.IsType<ItemContainerGenerator<TestItem>>(target.ItemContainerGenerator);
         }
 
-        [Fact]
-        public void Setting_SelectedIndex_Should_Show_Page()
+        public class Virtualized
         {
-            var target = new CarouselPresenter
+            [Fact]
+            public void Should_Initially_Materialize_Selected_Container()
             {
-                Items = new[] { "foo", "bar" },
-                SelectedIndex = 0,
-            };
+                var target = new CarouselPresenter
+                {
+                    Items = new[] { "foo", "bar" },
+                    SelectedIndex = 0,
+                    IsVirtualized = true,
+                };
 
-            target.ApplyTemplate();
+                target.ApplyTemplate();
 
-            Assert.IsType<ContentPresenter>(target.Panel.Children[0]);
-            Assert.Equal("foo", ((ContentPresenter)target.Panel.Children[0]).Content);
-        }
+                AssertSingle(target);
+            }
 
-        [Fact]
-        public void Changing_SelectedIndex_Should_Show_Page()
-        {
-            var target = new CarouselPresenter
+            [Fact]
+            public void Should_Initially_Materialize_Nothing_If_No_Selected_Container()
             {
-                Items = new[] { "foo", "bar" },
-                SelectedIndex = 0,
-            };
+                var target = new CarouselPresenter
+                {
+                    Items = new[] { "foo", "bar" },
+                    IsVirtualized = true,
+                };
 
-            target.ApplyTemplate();
-            target.SelectedIndex = 1;
+                target.ApplyTemplate();
 
-            Assert.IsType<ContentPresenter>(target.Panel.Children[0]);
-            Assert.Equal("bar", ((ContentPresenter)target.Panel.Children[0]).Content);
-        }
+                Assert.Empty(target.Panel.Children);
+                Assert.Empty(target.ItemContainerGenerator.Containers);
+            }
 
-        [Fact]
-        public void Should_Remove_NonCurrent_Page_When_IsVirtualized_True()
-        {
-            var target = new CarouselPresenter
+            [Fact]
+            public void Switching_To_Virtualized_Should_Reset_Containers()
             {
-                Items = new[] { "foo", "bar" },
-                IsVirtualized = true,
-                SelectedIndex = 0,
-            };
+                var target = new CarouselPresenter
+                {
+                    Items = new[] { "foo", "bar" },
+                    SelectedIndex = 0,
+                    IsVirtualized = false,
+                };
 
-            target.ApplyTemplate();
-            Assert.Single(target.ItemContainerGenerator.Containers);
-            target.SelectedIndex = 1;
-            Assert.Single(target.ItemContainerGenerator.Containers);
-        }
+                target.ApplyTemplate();
+                target.IsVirtualized = true;
 
-        [Fact]
-        public void Should_Not_Remove_NonCurrent_Page_When_IsVirtualized_False()
-        {
-            var target = new CarouselPresenter
+                AssertSingle(target);
+            }
+
+            [Fact]
+            public void Changing_SelectedIndex_Should_Show_Page()
             {
-                Items = new[] { "foo", "bar" },
-                IsVirtualized = false,
-                SelectedIndex = 0,
-            };
+                var target = new CarouselPresenter
+                {
+                    Items = new[] { "foo", "bar" },
+                    SelectedIndex = 0,
+                    IsVirtualized = true,
+                };
 
-            target.ApplyTemplate();
-            Assert.Single(target.ItemContainerGenerator.Containers);
-            Assert.Single(target.Panel.Children);
-            target.SelectedIndex = 1;
-            Assert.Equal(2, target.ItemContainerGenerator.Containers.Count());
-            Assert.Equal(2, target.Panel.Children.Count);
-            target.SelectedIndex = 0;
-            Assert.Equal(2, target.ItemContainerGenerator.Containers.Count());
-            Assert.Equal(2, target.Panel.Children.Count);
-        }
+                target.ApplyTemplate();
+                AssertSingle(target);
 
-        [Fact]
-        public void Should_Remove_Controls_When_IsVirtualized_Is_False()
-        {
-            ObservableCollection<string> items = new ObservableCollection<string>();
-            
-            var target = new CarouselPresenter
+                target.SelectedIndex = 1;
+                AssertSingle(target);
+            }
+
+            [Fact]
+            public void Should_Remove_NonCurrent_Page()
             {
-                Items = items,              
-                SelectedIndex = 0,
-                IsVirtualized = false,
-            };
+                var target = new CarouselPresenter
+                {
+                    Items = new[] { "foo", "bar" },
+                    IsVirtualized = true,
+                    SelectedIndex = 0,
+                };
 
-            target.ApplyTemplate();
-            target.SelectedIndex = 0;
-            items.Add("foo");
-            target.SelectedIndex = 0;
+                target.ApplyTemplate();
+                AssertSingle(target);
 
-            Assert.Single(target.ItemContainerGenerator.Containers);
-            Assert.Single(target.Panel.Children);
+                target.SelectedIndex = 1;
+                AssertSingle(target);
 
-            items.Add("bar");
-            Assert.Single(target.ItemContainerGenerator.Containers);
-            Assert.Single(target.Panel.Children);
+            }
 
-            target.SelectedIndex = 1;
-            Assert.Equal(2, target.ItemContainerGenerator.Containers.Count());
-            Assert.Equal(2, target.Panel.Children.Count);            
+            [Fact]
+            public void Should_Handle_Inserting_Item_At_SelectedItem()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
 
-            items.Remove(items[0]);
-            Assert.Single(target.ItemContainerGenerator.Containers);
-            Assert.Single(target.Panel.Children);            
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = true,
+                };
 
-            items.Remove(items[0]);
-            Assert.Empty(target.ItemContainerGenerator.Containers);
-            Assert.Empty(target.Panel.Children);            
-        }
+                target.ApplyTemplate();
 
-        [Fact]
-        public void Should_Have_Correct_ItemsContainer_Index()
-        {
-            ObservableCollection<string> items = new ObservableCollection<string>();
+                items.Insert(1, "item1a");
+                AssertSingle(target);
+            }
 
-            var target = new CarouselPresenter
+            [Fact]
+            public void Should_Handle_Inserting_Item_Before_SelectedItem()
             {
-                Items = items,
-                SelectedIndex = 0,
-                IsVirtualized = false,
-            };
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
 
-            target.ApplyTemplate();
-            target.SelectedIndex = 0;
-            items.Add("foo");
-            target.SelectedIndex = 0;
-
-            Assert.Single(target.ItemContainerGenerator.Containers);
-            Assert.Single(target.Panel.Children);
-
-            items.Add("bar");
-            Assert.Single(target.ItemContainerGenerator.Containers);
-            Assert.Single(target.Panel.Children);
-
-            target.SelectedIndex = 1;
-            Assert.Equal(2, target.ItemContainerGenerator.Containers.Count());
-            Assert.Equal(2, target.Panel.Children.Count);
-            Assert.Equal(0, target.ItemContainerGenerator.Containers.First().Index);
-
-            items.Remove(items[0]);
-            Assert.Single(target.ItemContainerGenerator.Containers);
-            Assert.Single(target.Panel.Children);
-            Assert.Equal(0, target.ItemContainerGenerator.Containers.First().Index);
-
-            items.Remove(items[0]);
-            Assert.Empty(target.ItemContainerGenerator.Containers);
-            Assert.Empty(target.Panel.Children);            
-        }
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 2,
+                    IsVirtualized = true,
+                };
 
-        [Fact]
-        public void Should_Handle_Inserting_Items_At_SelectedItem()
-        {
-            ObservableCollection<string> items = new ObservableCollection<string>
+                target.ApplyTemplate();
+
+                items.Insert(1, "item1a");
+                AssertSingle(target);
+            }
+
+            [Fact]
+            public void Should_Do_Nothing_When_Inserting_Item_After_SelectedItem()
             {
-                "item1",
-                "item2",
-                "item3",
-            };
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
 
-            var target = new CarouselPresenter
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = true,
+                };
+
+                target.ApplyTemplate();
+                var child = AssertSingle(target);
+                items.Insert(2, "after");
+                Assert.Same(child, AssertSingle(target));
+            }
+
+            [Fact]
+            public void Should_Handle_Removing_Item_At_SelectedItem()
             {
-                Items = items,
-                SelectedIndex = 0,
-                IsVirtualized = false,
-            };
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
 
-            target.ApplyTemplate();
-            target.SelectedIndex = 1;
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = true,
+                };
 
-            items.Insert(1, "item1a");
+                target.ApplyTemplate();
 
-            var containers = target.ItemContainerGenerator.Containers.Select(x => (x.Index, (string)x.Item));
+                items.RemoveAt(1);
+                AssertSingle(target);
+            }
 
-            Assert.Equal(
-                new[]
+            [Fact]
+            public void Should_Handle_Removing_Item_Before_SelectedItem()
+            {
+                var items = new ObservableCollection<string>
                 {
-                    (0, "item1"),
-                    (1, "item1a"),
-                    (2, "item2"),
-                },
-                containers);
+                    "item0",
+                    "item1",
+                    "item2",
+                };
 
-            var visibleContainer = (ContentPresenter)target.Panel.Children.Single(x => x.IsVisible);
-            Assert.Equal("item1a", visibleContainer.Content);
-        }
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = true,
+                };
 
-        [Fact]
-        public void Should_Handle_Inserting_Items_Before_SelectedItem()
-        {
-            ObservableCollection<string> items = new ObservableCollection<string>
+                target.ApplyTemplate();
+
+                items.RemoveAt(0);
+                AssertSingle(target);
+            }
+
+            [Fact]
+            public void Should_Do_Nothing_When_Removing_Item_After_SelectedItem()
             {
-                "item1",
-                "item2",
-                "item3",
-            };
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
 
-            var target = new CarouselPresenter
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = true,
+                };
+
+                target.ApplyTemplate();
+                var child = AssertSingle(target);
+                items.RemoveAt(2);
+                Assert.Same(child, AssertSingle(target));
+            }
+
+            [Fact]
+            public void Should_Handle_Removing_SelectedItem_When_Its_Last()
             {
-                Items = items,
-                SelectedIndex = 0,
-                IsVirtualized = false,
-            };
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
 
-            target.ApplyTemplate();
-            target.SelectedIndex = 2;
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 2,
+                    IsVirtualized = true,
+                };
+
+                target.ApplyTemplate();
+
+                items.RemoveAt(2);
+                Assert.Equal(1, target.SelectedIndex);
+                AssertSingle(target);
+            }
+
+            [Fact]
+            public void Should_Handle_Removing_Last_Item()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                };
+
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 0,
+                    IsVirtualized = true,
+                };
+
+                target.ApplyTemplate();
+
+                items.RemoveAt(0);
+                Assert.Empty(target.Panel.Children);
+                Assert.Empty(target.ItemContainerGenerator.Containers);
+            }
+
+            [Fact]
+            public void Should_Handle_Replacing_SelectedItem()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
+
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = true,
+                };
+
+                target.ApplyTemplate();
+
+                items[1] = "replaced";
+                AssertSingle(target);
+            }
+
+            [Fact]
+            public void Should_Do_Nothing_When_Replacing_Non_SelectedItem()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
 
-            items.Insert(1, "item1a");
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = true,
+                };
+
+                target.ApplyTemplate();
+                var child = AssertSingle(target);
+                items[0] = "replaced";
+                Assert.Same(child, AssertSingle(target));
+            }
 
-            var actual = target.ItemContainerGenerator.Containers.Select(x => (x.Index, (string)x.Item));
+            [Fact]
+            public void Should_Handle_Moving_SelectedItem()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
 
-            Assert.Equal(
-                new[]
+                var target = new CarouselPresenter
                 {
-                    (0, "item1"),
-                    (3, "item3"),
-                },
-                actual);
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = true,
+                };
+
+                target.ApplyTemplate();
+
+                items.Move(1, 0);
+                AssertSingle(target);
+            }
 
-            var visibleContainer = (ContentPresenter)target.Panel.Children.Single(x => x.IsVisible);
-            Assert.Equal("item3", visibleContainer.Content);
+            private static IControl AssertSingle(CarouselPresenter target)
+            {
+                var items = (IList)target.Items;
+                var index = target.SelectedIndex;
+                var content = items[index];
+                var child = Assert.Single(target.Panel.Children);
+                var presenter = Assert.IsType<ContentPresenter>(child);
+                var container = Assert.Single(target.ItemContainerGenerator.Containers);
+                var visible = Assert.Single(target.Panel.Children.Where(x => x.IsVisible));
+
+                Assert.Same(child, container.ContainerControl);
+                Assert.Same(child, visible);
+                Assert.Equal(content, presenter.Content);
+                Assert.Equal(content, container.Item);
+                Assert.Equal(index, container.Index);
+
+                return child;
+            }
         }
 
-        [Fact]
-        public void Should_Handle_Inserting_Items_After_SelectedItem()
+        public class NonVirtualized
         {
-            ObservableCollection<string> items = new ObservableCollection<string>
+            [Fact]
+            public void Should_Initially_Materialize_All_Containers()
             {
-                "item1",
-                "item2",
-                "item3",
-            };
+                var target = new CarouselPresenter
+                {
+                    Items = new[] { "foo", "bar" },
+                    IsVirtualized = false,
+                };
 
-            var target = new CarouselPresenter
+                target.ApplyTemplate();
+                AssertAll(target);
+            }
+
+            [Fact]
+            public void Should_Initially_Show_Selected_Item()
             {
-                Items = items,
-                SelectedIndex = 0,
-                IsVirtualized = false,
-            };
+                var target = new CarouselPresenter
+                {
+                    Items = new[] { "foo", "bar" },
+                    SelectedIndex = 1,
+                    IsVirtualized = false,
+                };
 
-            target.ApplyTemplate();
-            target.SelectedIndex = 1;
-            target.SelectedIndex = 0;
+                target.ApplyTemplate();
+                AssertAll(target);
+            }
+
+            [Fact]
+            public void Switching_To_Non_Virtualized_Should_Reset_Containers()
+            {
+                var target = new CarouselPresenter
+                {
+                    Items = new[] { "foo", "bar" },
+                    SelectedIndex = 0,
+                    IsVirtualized = true,
+                };
 
-            items.Insert(1, "item1a");
+                target.ApplyTemplate();
+                target.IsVirtualized = false;
 
-            var actual = target.ItemContainerGenerator.Containers.Select(x => (x.Index, (string)x.Item));
+                AssertAll(target);
+            }
 
-            Assert.Equal(
-                new[]
+            [Fact]
+            public void Changing_SelectedIndex_Should_Show_Page()
+            {
+                var target = new CarouselPresenter
                 {
-                    (0, "item1"),
-                    (2, "item2"),
-                },
-                actual);
+                    Items = new[] { "foo", "bar" },
+                    SelectedIndex = 0,
+                    IsVirtualized = false,
+                };
+
+                target.ApplyTemplate();
+                AssertAll(target);
+
+                target.SelectedIndex = 1;
+                AssertAll(target);
+            }
+
+            [Fact]
+            public void Should_Handle_Inserting_Item_At_SelectedItem()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
+
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = false,
+                };
+
+                target.ApplyTemplate();
+
+                items.Insert(1, "item1a");
+                AssertAll(target);
+            }
+
+            [Fact]
+            public void Should_Handle_Inserting_Item_Before_SelectedItem()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
+
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 2,
+                    IsVirtualized = false,
+                };
+
+                target.ApplyTemplate();
+
+                items.Insert(1, "item1a");
+                AssertAll(target);
+            }
+
+            [Fact]
+            public void Should_Do_Handle_Inserting_Item_After_SelectedItem()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
+
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = false,
+                };
+
+                target.ApplyTemplate();
+                items.Insert(2, "after");
+                AssertAll(target);
+            }
+
+            [Fact]
+            public void Should_Handle_Removing_Item_At_SelectedItem()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
+
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = false,
+                };
+
+                target.ApplyTemplate();
+
+                items.RemoveAt(1);
+                AssertAll(target);
+            }
+
+            [Fact]
+            public void Should_Handle_Removing_Item_Before_SelectedItem()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
+
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = false,
+                };
+
+                target.ApplyTemplate();
+
+                items.RemoveAt(0);
+                AssertAll(target);
+            }
+
+            [Fact]
+            public void Should_Handle_Removing_Item_After_SelectedItem()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
+
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = false,
+                };
+
+                target.ApplyTemplate();
+                items.RemoveAt(2);
+                AssertAll(target);
+            }
+
+            [Fact]
+            public void Should_Handle_Removing_SelectedItem_When_Its_Last()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
+
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 2,
+                    IsVirtualized = false,
+                };
+
+                target.ApplyTemplate();
+
+                items.RemoveAt(2);
+                Assert.Equal(1, target.SelectedIndex);
+                AssertAll(target);
+            }
+
+            [Fact]
+            public void Should_Handle_Removing_Last_Item()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                };
+
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 0,
+                    IsVirtualized = false,
+                };
+
+                target.ApplyTemplate();
+
+                items.RemoveAt(0);
+                Assert.Empty(target.Panel.Children);
+                Assert.Empty(target.ItemContainerGenerator.Containers);
+            }
+
+            [Fact]
+            public void Should_Handle_Replacing_SelectedItem()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
+
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = false,
+                };
+
+                target.ApplyTemplate();
+
+                items[1] = "replaced";
+                AssertAll(target);
+            }
+
+            [Fact]
+            public void Should_Handle_Moving_SelectedItem()
+            {
+                var items = new ObservableCollection<string>
+                {
+                    "item0",
+                    "item1",
+                    "item2",
+                };
+
+                var target = new CarouselPresenter
+                {
+                    Items = items,
+                    SelectedIndex = 1,
+                    IsVirtualized = false,
+                };
+
+                target.ApplyTemplate();
+
+                items.Move(1, 0);
+                AssertAll(target);
+            }
+
+            private static void AssertAll(CarouselPresenter target)
+            {
+                var items = (IList)target.Items;
+
+                Assert.Equal(items?.Count ?? 0, target.Panel.Children.Count);
+                Assert.Equal(items?.Count ?? 0, target.ItemContainerGenerator.Containers.Count());
+
+                for (var i = 0; i < items?.Count; ++i)
+                {
+                    var content = items[i];
+                    var child = target.Panel.Children[i];
+                    var presenter = Assert.IsType<ContentPresenter>(child);
+                    var container = target.ItemContainerGenerator.ContainerFromIndex(i);
+
+                    Assert.Same(child, container);
+                    Assert.Equal(i == target.SelectedIndex, child.IsVisible);
+                    Assert.Equal(content, presenter.Content);
+                    Assert.Equal(i, target.ItemContainerGenerator.IndexFromContainer(container));
+                }
+            }
         }
 
         private class TestItem : ContentControl

From 1cc4661c145f8ab66f87a8f671757bbe6d4eb166 Mon Sep 17 00:00:00 2001
From: Benedikt Schroeder <benedikt.schroeder@outlook.de>
Date: Sat, 4 May 2019 19:17:48 +0200
Subject: [PATCH 14/20] Simplified creation of FontFamily instances

---
 src/Avalonia.Visuals/Media/FontFamily.cs      | 110 ++++++++++--------
 .../Media/Fonts/FamilyNameCollection.cs       |  35 +++---
 .../Media/FontFamilyTests.cs                  |  13 ---
 .../Media/Fonts/FamilyNameCollectionTests.cs  |  11 +-
 4 files changed, 84 insertions(+), 85 deletions(-)

diff --git a/src/Avalonia.Visuals/Media/FontFamily.cs b/src/Avalonia.Visuals/Media/FontFamily.cs
index 5c152cd8a0..a486723d86 100644
--- a/src/Avalonia.Visuals/Media/FontFamily.cs
+++ b/src/Avalonia.Visuals/Media/FontFamily.cs
@@ -11,46 +11,49 @@ namespace Avalonia.Media
 {
     public class FontFamily
     {
+        /// <inheritdoc />
         /// <summary>
         /// Initializes a new instance of the <see cref="T:Avalonia.Media.FontFamily" /> class.
         /// </summary>
-        /// <param name="name">The name of the <see cref="FontFamily"/>.</param>
-        /// <exception cref="T:System.ArgumentNullException">name</exception>
-        public FontFamily(string name)
+        /// <param name="name">The name of the <see cref="T:Avalonia.Media.FontFamily" />.</param>
+        public FontFamily(string name) : this(null, name)
         {
-            Contract.Requires<ArgumentNullException>(name != null);
-
-            FamilyNames = new FamilyNameCollection(new[] { name });
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="T:Avalonia.Media.FontFamily" /> class.
         /// </summary>
-        /// <param name="names">The names of the <see cref="FontFamily"/>.</param>
-        /// <exception cref="T:System.ArgumentNullException">name</exception>
-        public FontFamily(IEnumerable<string> names)
+        /// <param name="baseUri">Specifies the base uri that is used to resolve font family assets.</param>
+        /// <param name="name">The name of the <see cref="T:Avalonia.Media.FontFamily" />.</param>
+        /// <exception cref="T:System.ArgumentException">Base uri must be an absolute uri.</exception>
+        public FontFamily(Uri baseUri, string name)
         {
-            Contract.Requires<ArgumentNullException>(names != null);
+            if (string.IsNullOrEmpty(name))
+            {
+                FamilyNames = new FamilyNameCollection(string.Empty);
 
-            FamilyNames = new FamilyNameCollection(names);
-        }
+                return;
+            }
 
-        /// <inheritdoc />
-        /// <summary>
-        /// Initializes a new instance of the <see cref="T:Avalonia.Media.FontFamily" /> class.
-        /// </summary>
-        /// <param name="name">The name of the <see cref="T:Avalonia.Media.FontFamily" />.</param>
-        /// <param name="source">The source of font resources.</param>
-        /// <param name="baseUri"></param>
-        public FontFamily(string name, Uri source, Uri baseUri = null) : this(name)
-        {
-            Key = new FontFamilyKey(source, baseUri);
+            var fontFamilySegment = GetFontFamilyIdentifier(name);
+
+            if (fontFamilySegment.Source != null)
+            {
+                if (baseUri != null && !baseUri.IsAbsoluteUri)
+                {
+                    throw new ArgumentException("Base uri must be an absolute uri.", nameof(baseUri));
+                }
+
+                Key = new FontFamilyKey(fontFamilySegment.Source, baseUri);
+            }
+
+            FamilyNames = new FamilyNameCollection(fontFamilySegment.Name);
         }
 
         /// <summary>
         /// Represents the default font family
         /// </summary>
-        public static FontFamily Default => new FontFamily(String.Empty);
+        public static FontFamily Default => new FontFamily(string.Empty);
 
         /// <summary>
         /// Represents all font families in the system. This can be an expensive call depending on platform implementation.
@@ -88,46 +91,40 @@ namespace Avalonia.Media
         /// <param name="s"></param>
         public static implicit operator FontFamily(string s)
         {
-            return Parse(s);
+            return new FontFamily(s);
         }
 
-        /// <summary>
-        /// Parses a <see cref="T:Avalonia.Media.FontFamily"/> string.
-        /// </summary>
-        /// <param name="s">The <see cref="T:Avalonia.Media.FontFamily"/> string.</param>
-        /// <param name="baseUri"></param>
-        /// <returns></returns>
-        /// <exception cref="ArgumentException">
-        /// Specified family is not supported.
-        /// </exception>
-        public static FontFamily Parse(string s, Uri baseUri = null)
+        private struct FontFamilyIdentifier
         {
-            if (string.IsNullOrEmpty(s))
+            public FontFamilyIdentifier(string name, Uri source)
             {
-                throw new ArgumentException("Specified family is not supported.");
+                Name = name;
+                Source = source;
             }
 
-            var segments = s.Split('#');
+            public string Name { get; }
+
+            public Uri Source { get; }
+        }
+
+        private static FontFamilyIdentifier GetFontFamilyIdentifier(string name)
+        {
+            var segments = name.Split('#');
 
             switch (segments.Length)
             {
                 case 1:
                     {
-                        var names = segments[0].Split(',')
-                            .Select(x => x.Trim())
-                            .Where(x => !string.IsNullOrWhiteSpace(x));
-                        return new FontFamily(names);
+                        return new FontFamilyIdentifier(segments[0], null);
                     }
 
                 case 2:
                     {
-                        var uri = segments[0].StartsWith("/")
-                                      ? new Uri(segments[0], UriKind.Relative)
-                                      : new Uri(segments[0], UriKind.RelativeOrAbsolute);
+                        var source = segments[0].StartsWith("/")
+                            ? new Uri(segments[0], UriKind.Relative)
+                            : new Uri(segments[0], UriKind.RelativeOrAbsolute);
 
-                        return uri.IsAbsoluteUri
-                                   ? new FontFamily(segments[1], uri)
-                                   : new FontFamily(segments[1], uri, baseUri);
+                        return new FontFamilyIdentifier(segments[1], source);
                     }
 
                 default:
@@ -137,6 +134,25 @@ namespace Avalonia.Media
             }
         }
 
+        /// <summary>
+        /// Parses a <see cref="T:Avalonia.Media.FontFamily"/> string.
+        /// </summary>
+        /// <param name="s">The <see cref="T:Avalonia.Media.FontFamily"/> string.</param>
+        /// <param name="baseUri">Specifies the base uri that is used to resolve font family assets.</param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentException">
+        /// Specified family is not supported.
+        /// </exception>
+        public static FontFamily Parse(string s, Uri baseUri = null)
+        {
+            if (string.IsNullOrEmpty(s))
+            {
+                throw new ArgumentException("Specified family is not supported.", nameof(s));
+            }
+
+            return new FontFamily(baseUri, s);
+        }
+
         /// <summary>
         /// Returns a <see cref="string" /> that represents this instance.
         /// </summary>
diff --git a/src/Avalonia.Visuals/Media/Fonts/FamilyNameCollection.cs b/src/Avalonia.Visuals/Media/Fonts/FamilyNameCollection.cs
index 50511d2fb7..acf0bbdb11 100644
--- a/src/Avalonia.Visuals/Media/Fonts/FamilyNameCollection.cs
+++ b/src/Avalonia.Visuals/Media/Fonts/FamilyNameCollection.cs
@@ -4,31 +4,28 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Linq;
+using System.Text;
 
 namespace Avalonia.Media.Fonts
 {
-    using System.Text;
-
     public class FamilyNameCollection : IEnumerable<string>
-    {    
+    {
         /// <summary>
         /// Initializes a new instance of the <see cref="FamilyNameCollection"/> class.
         /// </summary>
         /// <param name="familyNames">The family names.</param>
         /// <exception cref="ArgumentException">familyNames</exception>
-        public FamilyNameCollection(IEnumerable<string> familyNames)
+        public FamilyNameCollection(string familyNames)
         {
-            Contract.Requires<ArgumentNullException>(familyNames != null);
-
-            var names = new List<string>(familyNames);
-
-            if (names.Count == 0) throw new ArgumentException($"{nameof(familyNames)} must not be empty.");
+            if (familyNames == null)
+            {
+                throw new ArgumentNullException(nameof(familyNames));
+            }
 
-            Names = new ReadOnlyCollection<string>(names);
+            Names = familyNames.Split(',').Select(x => x.Trim()).ToArray();
 
-            PrimaryFamilyName = Names.First();
+            PrimaryFamilyName = Names[0];
 
             HasFallbacks = Names.Count > 1;
         }
@@ -55,7 +52,7 @@ namespace Avalonia.Media.Fonts
         /// <value>
         /// The names.
         /// </value>
-        internal ReadOnlyCollection<string> Names { get; }
+        internal IReadOnlyList<string> Names { get; }
 
         /// <inheritdoc />
         /// <summary>
@@ -95,7 +92,10 @@ namespace Avalonia.Media.Fonts
             {
                 builder.Append(Names[index]);
 
-                if (index == Names.Count - 1) break;
+                if (index == Names.Count - 1)
+                {
+                    break;
+                }
 
                 builder.Append(", ");
             }
@@ -123,9 +123,12 @@ namespace Avalonia.Media.Fonts
         /// </returns>
         public override bool Equals(object obj)
         {
-            if (!(obj is FamilyNameCollection other)) return false;
+            if (!(obj is FamilyNameCollection other))
+            {
+                return false;
+            }
 
             return other.ToString().Equals(ToString());
         }
     }
-}
\ No newline at end of file
+}
diff --git a/tests/Avalonia.Visuals.UnitTests/Media/FontFamilyTests.cs b/tests/Avalonia.Visuals.UnitTests/Media/FontFamilyTests.cs
index 4c7a89cbda..1cd1742f32 100644
--- a/tests/Avalonia.Visuals.UnitTests/Media/FontFamilyTests.cs
+++ b/tests/Avalonia.Visuals.UnitTests/Media/FontFamilyTests.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using Avalonia.Media;
 using Avalonia.Media.Fonts;
@@ -12,18 +11,6 @@ namespace Avalonia.Visuals.UnitTests.Media
 {
     public class FontFamilyTests
     {
-        [Fact]
-        public void Exception_Should_Be_Thrown_If_Name_Is_Null()
-        {
-            Assert.Throws<ArgumentNullException>(() => new FontFamily((string)null));
-        }
-
-        [Fact]
-        public void Exception_Should_Be_Thrown_If_Names_Is_Null()
-        {
-            Assert.Throws<ArgumentNullException>(() => new FontFamily((IEnumerable<string>)null));
-        }
-
         [Fact]
         public void Should_Implicitly_Convert_String_To_FontFamily()
         {
diff --git a/tests/Avalonia.Visuals.UnitTests/Media/Fonts/FamilyNameCollectionTests.cs b/tests/Avalonia.Visuals.UnitTests/Media/Fonts/FamilyNameCollectionTests.cs
index 14daf5bd8b..e7aa9daab3 100644
--- a/tests/Avalonia.Visuals.UnitTests/Media/Fonts/FamilyNameCollectionTests.cs
+++ b/tests/Avalonia.Visuals.UnitTests/Media/Fonts/FamilyNameCollectionTests.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT license. See licence.md file in the project root for full license information.
 
 using System;
-using System.Linq;
 using Avalonia.Media.Fonts;
 using Xunit;
 
@@ -16,18 +15,12 @@ namespace Avalonia.Visuals.UnitTests.Media.Fonts
             Assert.Throws<ArgumentNullException>(() => new FamilyNameCollection(null));
         }
 
-        [Fact]
-        public void Exception_Should_Be_Thrown_If_Names_Is_Empty()
-        {
-            Assert.Throws<ArgumentException>(() => new FamilyNameCollection(Enumerable.Empty<string>()));
-        }
-
         [Fact]
         public void Should_Be_Equal()
         {
-            var familyNames = new FamilyNameCollection(new[] { "Arial", "Times New Roman" });
+            var familyNames = new FamilyNameCollection("Arial, Times New Roman");
 
-            Assert.Equal(new FamilyNameCollection(new[] { "Arial", "Times New Roman" }), familyNames);
+            Assert.Equal(new FamilyNameCollection("Arial, Times New Roman"), familyNames);
         }
     }
 }

From e63fc96c848d9f89ec9dc49f15514defdc6a76ff Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Sun, 5 May 2019 21:12:01 +0200
Subject: [PATCH 15/20] Fix failing test.

And remove empty method.
---
 src/Avalonia.Controls/Presenters/CarouselPresenter.cs |  5 -----
 .../Primitives/SelectingItemsControl.cs               | 11 ++++++++---
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/Avalonia.Controls/Presenters/CarouselPresenter.cs b/src/Avalonia.Controls/Presenters/CarouselPresenter.cs
index bdc4d29400..f887b987e0 100644
--- a/src/Avalonia.Controls/Presenters/CarouselPresenter.cs
+++ b/src/Avalonia.Controls/Presenters/CarouselPresenter.cs
@@ -94,11 +94,6 @@ namespace Avalonia.Controls.Presenters
             set { SetValue(PageTransitionProperty, value); }
         }
 
-        protected override void PanelCreated(IPanel panel)
-        {
-            base.PanelCreated(panel);
-        }
-
         /// <inheritdoc/>
         protected override void ItemsChanged(NotifyCollectionChangedEventArgs e)
         {
diff --git a/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs b/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs
index a64dbe0546..280c3ad93a 100644
--- a/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs
+++ b/src/Avalonia.Controls/Primitives/SelectingItemsControl.cs
@@ -325,14 +325,19 @@ namespace Avalonia.Controls.Primitives
 
             if (_updateCount == 0)
             {
+                var newIndex = -1;
+
                 if (SelectedIndex != -1)
                 {
-                    SelectedIndex = IndexOf((IEnumerable)e.NewValue, SelectedItem);
+                    newIndex = IndexOf((IEnumerable)e.NewValue, SelectedItem);
                 }
-                else if (AlwaysSelected && Items != null && Items.Cast<object>().Any())
+
+                if (AlwaysSelected && Items != null && Items.Cast<object>().Any())
                 {
-                    SelectedIndex = 0;
+                    newIndex = 0;
                 }
+
+                SelectedIndex = newIndex;
             }
         }
 

From 8a179816eda1d054d57fa949118157c074c2ad3c Mon Sep 17 00:00:00 2001
From: Benedikt Schroeder <benedikt.schroeder@outlook.de>
Date: Mon, 6 May 2019 12:28:19 +0200
Subject: [PATCH 16/20] Target TabItem itself instead of ContentPresenter for
 default selectors

---
 samples/ControlCatalog/SideBar.xaml      |  4 ++--
 src/Avalonia.Themes.Default/TabItem.xaml | 10 +++++-----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/samples/ControlCatalog/SideBar.xaml b/samples/ControlCatalog/SideBar.xaml
index fea55bcb07..0eae348717 100644
--- a/samples/ControlCatalog/SideBar.xaml
+++ b/samples/ControlCatalog/SideBar.xaml
@@ -63,13 +63,13 @@
     <Style Selector="TabControl.sidebar > TabItem:pointerover">
         <Setter Property="Opacity" Value="1"/>
     </Style>
-    <Style Selector="TabControl.sidebar > TabItem:pointerover /template/ ContentPresenter#PART_ContentPresenter">
+    <Style Selector="TabControl.sidebar > TabItem:pointerover">
         <Setter Property="Background" Value="Transparent"/>
     </Style>
     <Style Selector="TabControl.sidebar > TabItem:selected">
         <Setter Property="Opacity" Value="1"/>
     </Style>
-    <Style Selector="TabControl.sidebar > TabItem:selected /template/ ContentPresenter#PART_ContentPresenter">
+    <Style Selector="TabControl.sidebar > TabItem:selected">
         <Setter Property="Background" Value="{DynamicResource ThemeAccentBrush2}"/>
     </Style>
 </Styles>
diff --git a/src/Avalonia.Themes.Default/TabItem.xaml b/src/Avalonia.Themes.Default/TabItem.xaml
index fcdb76524e..92482a564c 100644
--- a/src/Avalonia.Themes.Default/TabItem.xaml
+++ b/src/Avalonia.Themes.Default/TabItem.xaml
@@ -24,19 +24,19 @@
     <Style Selector="TabItem:disabled">
         <Setter Property="Opacity" Value="{DynamicResource ThemeDisabledOpacity}"/>
     </Style>
-    <Style Selector="TabItem:pointerover /template/ ContentPresenter#PART_ContentPresenter">
+    <Style Selector="TabItem:pointerover">
         <Setter Property="Background" Value="{DynamicResource ThemeControlHighlightMidBrush}"/>
     </Style>
-    <Style Selector="TabItem:selected /template/ ContentPresenter#PART_ContentPresenter">
+    <Style Selector="TabItem:selected">
         <Setter Property="Background" Value="{DynamicResource ThemeAccentBrush4}"/>
     </Style>
-    <Style Selector="TabItem:selected:focus /template/ ContentPresenter#PART_ContentPresenter">
+    <Style Selector="TabItem:selected:focus">
         <Setter Property="Background" Value="{DynamicResource ThemeAccentBrush3}"/>
     </Style>
-    <Style Selector="TabItem:selected:pointerover /template/ ContentPresenter#PART_ContentPresenter">
+    <Style Selector="TabItem:selected:pointerover">
         <Setter Property="Background" Value="{DynamicResource ThemeAccentBrush3}"/>
     </Style>
-    <Style Selector="TabItem:selected:focus:pointerover /template/ ContentPresenter#PART_ContentPresenter">
+    <Style Selector="TabItem:selected:focus:pointerover">
         <Setter Property="Background" Value="{DynamicResource ThemeAccentBrush2}"/>
     </Style>
     <Style Selector="TabItem[TabStripPlacement=Right]">

From bbccc6e355e6430069a1110b82460c0845e3513e Mon Sep 17 00:00:00 2001
From: Benedikt Schroeder <benedikt.schroeder@outlook.de>
Date: Mon, 6 May 2019 13:28:40 +0200
Subject: [PATCH 17/20] Add more unit tests

---
 .../Media/Fonts/FontFamilyKey.cs              |  2 +-
 .../Media/FontFamilyTests.cs                  | 35 ++++++++++++++++---
 2 files changed, 32 insertions(+), 5 deletions(-)

diff --git a/src/Avalonia.Visuals/Media/Fonts/FontFamilyKey.cs b/src/Avalonia.Visuals/Media/Fonts/FontFamilyKey.cs
index 76ee2b7aad..7733dd7d2a 100644
--- a/src/Avalonia.Visuals/Media/Fonts/FontFamilyKey.cs
+++ b/src/Avalonia.Visuals/Media/Fonts/FontFamilyKey.cs
@@ -95,7 +95,7 @@ namespace Avalonia.Media.Fonts
         {
             if (!Source.IsAbsoluteUri && BaseUri != null)
             {
-                return BaseUri.Authority + Source;
+                return BaseUri.AbsoluteUri + Source.OriginalString;
             }
 
             return Source.ToString();
diff --git a/tests/Avalonia.Visuals.UnitTests/Media/FontFamilyTests.cs b/tests/Avalonia.Visuals.UnitTests/Media/FontFamilyTests.cs
index 1cd1742f32..75ae43a1fa 100644
--- a/tests/Avalonia.Visuals.UnitTests/Media/FontFamilyTests.cs
+++ b/tests/Avalonia.Visuals.UnitTests/Media/FontFamilyTests.cs
@@ -28,7 +28,7 @@ namespace Avalonia.Visuals.UnitTests.Media
         }
 
         [Fact]
-        public void Parse_Parses_FontFamily_With_Name()
+        public void Should_Parse_FontFamily_With_SystemFont_Name()
         {
             var fontFamily = FontFamily.Parse("Courier New");
 
@@ -36,7 +36,7 @@ namespace Avalonia.Visuals.UnitTests.Media
         }
 
         [Fact]
-        public void Parse_Parses_FontFamily_With_Names()
+        public void Should_Parse_FontFamily_With_Fallbacks()
         {
             var fontFamily = FontFamily.Parse("Courier New, Times New Roman");
 
@@ -48,7 +48,7 @@ namespace Avalonia.Visuals.UnitTests.Media
         }
 
         [Fact]
-        public void Parse_Parses_FontFamily_With_Resource_Folder()
+        public void Should_Parse_FontFamily_With_Resource_Folder()
         {
             var source = new Uri("resm:Avalonia.Visuals.UnitTests#MyFont");
 
@@ -62,7 +62,7 @@ namespace Avalonia.Visuals.UnitTests.Media
         }
 
         [Fact]
-        public void Parse_Parses_FontFamily_With_Resource_Filename()
+        public void Should_Parse_FontFamily_With_Resource_Filename()
         {
             var source = new Uri("resm:Avalonia.Visuals.UnitTests.MyFont.ttf#MyFont");
 
@@ -74,5 +74,32 @@ namespace Avalonia.Visuals.UnitTests.Media
 
             Assert.Equal(key, fontFamily.Key);
         }
+
+        [Theory]
+        [InlineData("resm:Avalonia.Visuals.UnitTests/Assets/Fonts#MyFont")]
+        [InlineData("avares://Avalonia.Visuals.UnitTests/Assets/Fonts#MyFont")]
+        public void Should_Create_FontFamily_From_Uri(string name)
+        {
+            var fontFamily = new FontFamily(name);
+
+            Assert.Equal("MyFont", fontFamily.Name);
+
+            Assert.NotNull(fontFamily.Key);
+        }
+
+        [Theory]
+        [InlineData("resm:Avalonia.Visuals.UnitTests.Assets.Fonts", "#MyFont")]
+        [InlineData("avares://Avalonia.Visuals.UnitTests/Assets/Fonts", "#MyFont")]
+        [InlineData("avares://Avalonia.Visuals.UnitTests", "/Assets/Fonts#MyFont")]
+        public void Should_Create_FontFamily_From_Uri_With_Base_Uri(string @base, string name)
+        {
+            var baseUri = new Uri(@base);
+
+            var fontFamily = new FontFamily(baseUri, name);
+
+            Assert.Equal("MyFont", fontFamily.Name);
+
+            Assert.NotNull(fontFamily.Key);
+        }
     }
 }

From 80ff9a0737e73d89578200eadd29719986ddf28a Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Tue, 7 May 2019 12:47:17 +0300
Subject: [PATCH 18/20] [X11] Use UIntPtr for serial field in XI2 structs

---
 src/Avalonia.X11/XIStructs.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Avalonia.X11/XIStructs.cs b/src/Avalonia.X11/XIStructs.cs
index 772bd1989c..ef49a72c43 100644
--- a/src/Avalonia.X11/XIStructs.cs
+++ b/src/Avalonia.X11/XIStructs.cs
@@ -197,7 +197,7 @@ namespace Avalonia.X11
     unsafe struct XIDeviceChangedEvent
     {
         public int Type; /* GenericEvent */
-        public ulong Serial; /* # of last request processed by server */
+        public UIntPtr Serial; /* # of last request processed by server */
         public Bool SendEvent; /* true if this came from a SendEvent request */
         public IntPtr Display; /* Display the event was read from */
         public int Extension; /* XI extension offset */
@@ -214,7 +214,7 @@ namespace Avalonia.X11
     struct XIDeviceEvent
     {
         public XEventName type; /* GenericEvent */
-        public ulong serial; /* # of last request processed by server */
+        public UIntPtr serial; /* # of last request processed by server */
         public Bool send_event; /* true if this came from a SendEvent request */
         public IntPtr display; /* Display the event was read from */
         public int extension; /* XI extension offset */
@@ -241,7 +241,7 @@ namespace Avalonia.X11
     unsafe struct XIEvent
     {
         public int type; /* GenericEvent */
-        public ulong serial; /* # of last request processed by server */
+        public UIntPtr serial; /* # of last request processed by server */
         public Bool send_event; /* true if this came from a SendEvent request */
         public IntPtr display; /* Display the event was read from */
         public int extension; /* XI extension offset */

From 92284afa14a42b26ad4d8893c0b923d17f9e8a69 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Sat, 11 May 2019 12:22:26 +0200
Subject: [PATCH 19/20] Added failing test for #2507.

---
 .../CarouselTests.cs                          | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/tests/Avalonia.Controls.UnitTests/CarouselTests.cs b/tests/Avalonia.Controls.UnitTests/CarouselTests.cs
index 2070b4b66a..515e18434d 100644
--- a/tests/Avalonia.Controls.UnitTests/CarouselTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/CarouselTests.cs
@@ -152,6 +152,29 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal("Bar", ((TextBlock)child).Text);
         }
 
+        [Fact]
+        public void Selected_Item_Changes_To_First_Item_When_Item_Added()
+        {
+            var items = new ObservableCollection<string>();
+            var target = new Carousel
+            {
+                Template = new FuncControlTemplate<Carousel>(CreateTemplate),
+                Items = items,
+                IsVirtualized = false
+            };
+
+            target.ApplyTemplate();
+            target.Presenter.ApplyTemplate();
+
+            Assert.Equal(-1, target.SelectedIndex);
+            Assert.Empty(target.GetLogicalChildren());
+
+            items.Add("Foo");
+
+            Assert.Equal(0, target.SelectedIndex);
+            Assert.Single(target.GetLogicalChildren());
+        }
+
         [Fact]
         public void Selected_Index_Changes_To_When_Items_Assigned_Null()
         {

From cb1882f9209a6519b10c720e6ae7bb2cd34a9462 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 10 May 2019 23:48:34 +0200
Subject: [PATCH 20/20] Only generate containers on the fly if virtualized.

Fixes #2507
---
 src/Avalonia.Controls/Presenters/CarouselPresenter.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/Presenters/CarouselPresenter.cs b/src/Avalonia.Controls/Presenters/CarouselPresenter.cs
index f887b987e0..a3123cf8c6 100644
--- a/src/Avalonia.Controls/Presenters/CarouselPresenter.cs
+++ b/src/Avalonia.Controls/Presenters/CarouselPresenter.cs
@@ -210,7 +210,7 @@ namespace Avalonia.Controls.Presenters
         {
             var container = ItemContainerGenerator.ContainerFromIndex(index);
 
-            if (container == null)
+            if (container == null && IsVirtualized)
             {
                 var item = Items.Cast<object>().ElementAt(index);
                 var materialized = ItemContainerGenerator.Materialize(index, item, MemberSelector);