From 86f7918d4da888765020df56547c26d51b44ff53 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Tue, 2 Apr 2019 13:26:31 +0200
Subject: [PATCH 01/11] Added failing tests for #2350.

---
 .../StackPanelTests.cs                        | 160 +++++++++++++++++-
 1 file changed, 159 insertions(+), 1 deletion(-)

diff --git a/tests/Avalonia.Controls.UnitTests/StackPanelTests.cs b/tests/Avalonia.Controls.UnitTests/StackPanelTests.cs
index ba2716775a..722ad1c8ee 100644
--- a/tests/Avalonia.Controls.UnitTests/StackPanelTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/StackPanelTests.cs
@@ -1,7 +1,8 @@
 // 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 Avalonia.Controls;
+using System.Linq;
+using Avalonia.Layout;
 using Xunit;
 
 namespace Avalonia.Controls.UnitTests
@@ -147,6 +148,151 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(new Rect(50, 0, 50, 120), target.Children[2].Bounds);
         }
 
+        [Fact]
+        public void Arranges_Vertical_Children_With_Correct_Bounds()
+        {
+            var target = new StackPanel
+            {
+                Orientation = Orientation.Vertical,
+                Children =
+                {
+                    new TestControl
+                    {
+                        HorizontalAlignment = HorizontalAlignment.Left,
+                        MeasureSize = new Size(50, 10),
+                    },
+                    new TestControl
+                    {
+                        HorizontalAlignment = HorizontalAlignment.Left,
+                        MeasureSize = new Size(150, 10),
+                    },
+                    new TestControl
+                    {
+                        HorizontalAlignment = HorizontalAlignment.Center,
+                        MeasureSize = new Size(50, 10),
+                    },
+                    new TestControl
+                    {
+                        HorizontalAlignment = HorizontalAlignment.Center,
+                        MeasureSize = new Size(150, 10),
+                    },
+                    new TestControl
+                    {
+                        HorizontalAlignment = HorizontalAlignment.Right,
+                        MeasureSize = new Size(50, 10),
+                    },
+                    new TestControl
+                    {
+                        HorizontalAlignment = HorizontalAlignment.Right,
+                        MeasureSize = new Size(150, 10),
+                    },
+                    new TestControl
+                    {
+                        HorizontalAlignment = HorizontalAlignment.Stretch,
+                        MeasureSize = new Size(50, 10),
+                    },
+                    new TestControl
+                    {
+                        HorizontalAlignment = HorizontalAlignment.Stretch,
+                        MeasureSize = new Size(150, 10),
+                    },
+                }
+            };
+
+            target.Measure(new Size(100, 150));
+            Assert.Equal(new Size(100, 80), target.DesiredSize);
+
+            target.Arrange(new Rect(target.DesiredSize));
+
+            var bounds = target.Children.Select(x => x.Bounds).ToArray();
+
+            Assert.Equal(
+                new[]
+                {
+                    new Rect(0, 0, 50, 10),
+                    new Rect(0, 10, 150, 10),
+                    new Rect(25, 20, 50, 10),
+                    new Rect(-25, 30, 150, 10),
+                    new Rect(50, 40, 50, 10),
+                    new Rect(-50, 50, 150, 10),
+                    new Rect(0, 60, 100, 10),
+                    new Rect(0, 70, 150, 10),
+
+                }, bounds);
+        }
+
+        [Fact]
+        public void Arranges_Horizontal_Children_With_Correct_Bounds()
+        {
+            var target = new StackPanel
+            {
+                Orientation = Orientation.Horizontal,
+                Children =
+                {
+                    new TestControl
+                    {
+                        VerticalAlignment = VerticalAlignment.Top,
+                        MeasureSize = new Size(10, 50),
+                    },
+                    new TestControl
+                    {
+                        VerticalAlignment = VerticalAlignment.Top,
+                        MeasureSize = new Size(10, 150),
+                    },
+                    new TestControl
+                    {
+                        VerticalAlignment = VerticalAlignment.Center,
+                        MeasureSize = new Size(10, 50),
+                    },
+                    new TestControl
+                    {
+                        VerticalAlignment = VerticalAlignment.Center,
+                        MeasureSize = new Size(10, 150),
+                    },
+                    new TestControl
+                    {
+                        VerticalAlignment = VerticalAlignment.Bottom,
+                        MeasureSize = new Size(10, 50),
+                    },
+                    new TestControl
+                    {
+                        VerticalAlignment = VerticalAlignment.Bottom,
+                        MeasureSize = new Size(10, 150),
+                    },
+                    new TestControl
+                    {
+                        VerticalAlignment = VerticalAlignment.Stretch,
+                        MeasureSize = new Size(10, 50),
+                    },
+                    new TestControl
+                    {
+                        VerticalAlignment = VerticalAlignment.Stretch,
+                        MeasureSize = new Size(10, 150),
+                    },
+                }
+            };
+
+            target.Measure(new Size(150, 100));
+            Assert.Equal(new Size(80, 100), target.DesiredSize);
+
+            target.Arrange(new Rect(target.DesiredSize));
+
+            var bounds = target.Children.Select(x => x.Bounds).ToArray();
+
+            Assert.Equal(
+                new[]
+                {
+                    new Rect(0, 0, 10, 50),
+                    new Rect(10, 0, 10, 150),
+                    new Rect(20, 25, 10, 50),
+                    new Rect(30, -25, 10, 150),
+                    new Rect(40, 50, 10, 50),
+                    new Rect(50, -50, 10, 150),
+                    new Rect(60, 0, 10, 100),
+                    new Rect(70, 0, 10, 150),
+                }, bounds);
+        }
+
         [Theory]
         [InlineData(Orientation.Horizontal)]
         [InlineData(Orientation.Vertical)]
@@ -185,5 +331,17 @@ namespace Avalonia.Controls.UnitTests
 
             Assert.Equal(sizeWithTwoChildren, sizeWithThreeChildren);
         }
+
+        private class TestControl : Control
+        {
+            public Size MeasureConstraint { get; private set; }
+            public Size MeasureSize { get; set; }
+
+            protected override Size MeasureOverride(Size availableSize)
+            {
+                MeasureConstraint = availableSize;
+                return MeasureSize;
+            }
+        }
     }
 }

From 7ac3556983050b29c8543321d51d272eecefb9b5 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Tue, 2 Apr 2019 14:24:06 +0200
Subject: [PATCH 02/11] Fixed StackPanel arrange pass.

Now follow's WPF's behavior better. In order to get the desired outcome, the `.Constrain(availableSize)` call in `Layoutable.Measure` had to be removed. Controls that relied on that (`Image` and `ViewBox`) have to now call `Constrain` themselves.

Fixes #2350
---
 src/Avalonia.Controls/Image.cs          | 11 ++---
 src/Avalonia.Controls/StackPanel.cs     | 54 ++++++---------------
 src/Avalonia.Controls/Viewbox.cs        |  2 +-
 src/Avalonia.Layout/LayoutExtensions.cs | 62 +++++++++++++++++++++++++
 src/Avalonia.Layout/Layoutable.cs       |  2 +-
 5 files changed, 84 insertions(+), 47 deletions(-)
 create mode 100644 src/Avalonia.Layout/LayoutExtensions.cs

diff --git a/src/Avalonia.Controls/Image.cs b/src/Avalonia.Controls/Image.cs
index c696fe7975..fa6f5787be 100644
--- a/src/Avalonia.Controls/Image.cs
+++ b/src/Avalonia.Controls/Image.cs
@@ -81,23 +81,22 @@ namespace Avalonia.Controls
         protected override Size MeasureOverride(Size availableSize)
         {
             var source = Source;
+            var result = new Size();
 
             if (source != null)
             {
                 Size sourceSize = new Size(source.PixelSize.Width, source.PixelSize.Height);
                 if (double.IsInfinity(availableSize.Width) || double.IsInfinity(availableSize.Height))
                 {
-                    return sourceSize;
+                    result = sourceSize;
                 }
                 else
                 {
-                    return Stretch.CalculateSize(availableSize, sourceSize);
+                    result = Stretch.CalculateSize(availableSize, sourceSize);
                 }
             }
-            else
-            {
-                return new Size();
-            }
+
+            return result.Constrain(availableSize);
         }
 
         /// <inheritdoc/>
diff --git a/src/Avalonia.Controls/StackPanel.cs b/src/Avalonia.Controls/StackPanel.cs
index df0c113cc0..d89df8556b 100644
--- a/src/Avalonia.Controls/StackPanel.cs
+++ b/src/Avalonia.Controls/StackPanel.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Linq;
 using Avalonia.Input;
+using Avalonia.Layout;
 
 namespace Avalonia.Controls
 {
@@ -219,30 +220,16 @@ namespace Avalonia.Controls
                 measuredWidth -= (hasVisibleChild ? spacing : 0);
             }
 
-            return new Size(measuredWidth, measuredHeight);
+            return new Size(measuredWidth, measuredHeight).Constrain(availableSize);
         }
 
-        /// <summary>
-        /// Arranges the control's children.
-        /// </summary>
-        /// <param name="finalSize">The size allocated to the control.</param>
-        /// <returns>The space taken.</returns>
+        /// <inheritdoc/>
         protected override Size ArrangeOverride(Size finalSize)
         {
             var orientation = Orientation;
-            double arrangedWidth = finalSize.Width;
-            double arrangedHeight = finalSize.Height;
-            double spacing = Spacing;
-            bool hasVisibleChild = Children.Any(c => c.IsVisible);
-
-            if (Orientation == Orientation.Vertical)
-            {
-                arrangedHeight = 0;
-            }
-            else
-            {
-                arrangedWidth = 0;
-            }
+            var spacing = Spacing;
+            var finalRect = new Rect(finalSize);
+            var pos = 0.0;
 
             foreach (Control child in Children)
             {
@@ -251,32 +238,21 @@ namespace Avalonia.Controls
 
                 if (orientation == Orientation.Vertical)
                 {
-                    double width = Math.Max(childWidth, arrangedWidth);
-                    Rect childFinal = new Rect(0, arrangedHeight, width, childHeight);
-                    ArrangeChild(child, childFinal, finalSize, orientation);
-                    arrangedWidth = Math.Max(arrangedWidth, childWidth);
-                    arrangedHeight += childHeight + (child.IsVisible ? spacing : 0);
+                    var rect = new Rect(0, pos, childWidth, childHeight)
+                        .Align(finalRect, child.HorizontalAlignment, VerticalAlignment.Top);
+                    ArrangeChild(child, rect, finalSize, orientation);
+                    pos += childHeight + spacing;
                 }
                 else
                 {
-                    double height = Math.Max(childHeight, arrangedHeight);
-                    Rect childFinal = new Rect(arrangedWidth, 0, childWidth, height);
-                    ArrangeChild(child, childFinal, finalSize, orientation);
-                    arrangedWidth += childWidth + (child.IsVisible ? spacing : 0);
-                    arrangedHeight = Math.Max(arrangedHeight, childHeight);
+                    var rect = new Rect(pos, 0, childWidth, childHeight)
+                        .Align(finalRect, HorizontalAlignment.Left, child.VerticalAlignment);
+                    ArrangeChild(child, rect, finalSize, orientation);
+                    pos += childWidth + spacing;
                 }
             }
 
-            if (orientation == Orientation.Vertical)
-            {
-                arrangedHeight = Math.Max(arrangedHeight - (hasVisibleChild ? spacing : 0), finalSize.Height);
-            }
-            else
-            {
-                arrangedWidth = Math.Max(arrangedWidth - (hasVisibleChild ? spacing : 0), finalSize.Width);
-            }
-
-            return new Size(arrangedWidth, arrangedHeight);
+            return finalSize;
         }
 
         internal virtual void ArrangeChild(
diff --git a/src/Avalonia.Controls/Viewbox.cs b/src/Avalonia.Controls/Viewbox.cs
index 3a070d07b2..781c93bcbe 100644
--- a/src/Avalonia.Controls/Viewbox.cs
+++ b/src/Avalonia.Controls/Viewbox.cs
@@ -49,7 +49,7 @@ namespace Avalonia.Controls
 
                 var scale = GetScale(availableSize, childSize, Stretch);
 
-                return childSize * scale;
+                return (childSize * scale).Constrain(availableSize);
             }
 
             return new Size();
diff --git a/src/Avalonia.Layout/LayoutExtensions.cs b/src/Avalonia.Layout/LayoutExtensions.cs
new file mode 100644
index 0000000000..737bbb083c
--- /dev/null
+++ b/src/Avalonia.Layout/LayoutExtensions.cs
@@ -0,0 +1,62 @@
+using System;
+
+namespace Avalonia.Layout
+{
+    /// <summary>
+    /// Extension methods for layout types.
+    /// </summary>
+    public static class LayoutExtensions
+    {
+        /// <summary>
+        /// Aligns a rect in a constraining rect according to horizontal and vertical alignment
+        /// settings.
+        /// </summary>
+        /// <param name="rect">The rect to align.</param>
+        /// <param name="constraint">The constraining rect.</param>
+        /// <param name="horizontalAlignment">The horizontal alignment.</param>
+        /// <param name="verticalAlignment">The vertical alignment.</param>
+        /// <returns></returns>
+        public static Rect Align(
+            this Rect rect,
+            Rect constraint,
+            HorizontalAlignment horizontalAlignment,
+            VerticalAlignment verticalAlignment)
+        {
+            switch (horizontalAlignment)
+            {
+                case HorizontalAlignment.Center:
+                    rect = rect.WithX((constraint.Width - rect.Width) / 2);
+                    break;
+                case HorizontalAlignment.Right:
+                    rect = rect.WithX(constraint.Width - rect.Width);
+                    break;
+                case HorizontalAlignment.Stretch:
+                    rect = new Rect(
+                        0,
+                        rect.Y,
+                        Math.Max(constraint.Width, rect.Width),
+                        rect.Height);
+                    break;
+            }
+
+            switch (verticalAlignment)
+            {
+                case VerticalAlignment.Center:
+                    rect = rect.WithY((constraint.Height - rect.Height) / 2);
+                    break;
+                case VerticalAlignment.Bottom:
+                    rect = rect.WithY(constraint.Height - rect.Height);
+                    break;
+                case VerticalAlignment.Stretch:
+                    rect = new Rect(
+                        rect.X,
+                        0,
+                        rect.Width,
+                        Math.Max(constraint.Height, rect.Height));
+                    break;
+            }
+
+            return rect;
+        }
+    }
+}
diff --git a/src/Avalonia.Layout/Layoutable.cs b/src/Avalonia.Layout/Layoutable.cs
index d5e3a1631e..662f48ec44 100644
--- a/src/Avalonia.Layout/Layoutable.cs
+++ b/src/Avalonia.Layout/Layoutable.cs
@@ -314,7 +314,7 @@ namespace Avalonia.Layout
                 try
                 {
                     _measuring = true;
-                    desiredSize = MeasureCore(availableSize).Constrain(availableSize);
+                    desiredSize = MeasureCore(availableSize);
                 }
                 finally
                 {

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 03/11] 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 04/11] 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 baa7c9da69b232b13386bfb414ff537a744f4a81 Mon Sep 17 00:00:00 2001
From: Benedikt Schroeder <benedikt.schroeder@outlook.de>
Date: Thu, 11 Apr 2019 17:49:56 +0200
Subject: [PATCH 05/11] Makes ScrollBar Thumb stylable

---
 src/Avalonia.Themes.Default/ScrollBar.xaml | 34 +++++++++++++++-------
 1 file changed, 24 insertions(+), 10 deletions(-)

diff --git a/src/Avalonia.Themes.Default/ScrollBar.xaml b/src/Avalonia.Themes.Default/ScrollBar.xaml
index 2cb8ce2d24..edd678ed56 100644
--- a/src/Avalonia.Themes.Default/ScrollBar.xaml
+++ b/src/Avalonia.Themes.Default/ScrollBar.xaml
@@ -31,11 +31,18 @@
                                               Focusable="False"/>
                             </Track.IncreaseButton>
                             <Thumb Name="thumb">
-                                <Thumb.Template>
-                                    <ControlTemplate>
-                                        <Border Background="{DynamicResource ThemeControlHighBrush}" />
-                                    </ControlTemplate>
-                                </Thumb.Template>
+                                <Thumb.Styles>
+                                    <Style Selector="Thumb">
+                                        <Setter Property="Background" Value="{DynamicResource ThemeControlHighBrush}"/>
+                                        <Setter Property="Template">
+                                            <Setter.Value>
+                                                <ControlTemplate>
+                                                    <Border Background="{TemplateBinding Background}"/>
+                                                </ControlTemplate>
+                                            </Setter.Value>
+                                        </Setter>
+                                    </Style>
+                                </Thumb.Styles>
                             </Thumb>
                         </Track>
                         <RepeatButton Name="PART_LineDownButton"
@@ -85,11 +92,18 @@
                                               Focusable="False"/>
                             </Track.IncreaseButton>
                             <Thumb Name="thumb">
-                                <Thumb.Template>
-                                    <ControlTemplate>
-                                        <Border Background="{DynamicResource ThemeControlHighBrush}" />
-                                    </ControlTemplate>
-                                </Thumb.Template>
+                                <Thumb.Styles>
+                                    <Style Selector="Thumb">
+                                        <Setter Property="Background" Value="{DynamicResource ThemeControlHighBrush}"/>
+                                        <Setter Property="Template">
+                                            <Setter.Value>
+                                                <ControlTemplate>
+                                                    <Border Background="{TemplateBinding Background}"/>
+                                                </ControlTemplate>
+                                            </Setter.Value>
+                                        </Setter>
+                                    </Style>
+                                </Thumb.Styles>
                             </Thumb>
                         </Track>
                         <RepeatButton Name="PART_LineDownButton"

From 55e64e4c744b6836c26cc4409561b3930c441632 Mon Sep 17 00:00:00 2001
From: Benedikt Schroeder <benedikt.schroeder@outlook.de>
Date: Fri, 12 Apr 2019 11:32:59 +0200
Subject: [PATCH 06/11] Move Thumb style outside the control template

---
 src/Avalonia.Themes.Default/ScrollBar.xaml | 40 +++++++---------------
 1 file changed, 12 insertions(+), 28 deletions(-)

diff --git a/src/Avalonia.Themes.Default/ScrollBar.xaml b/src/Avalonia.Themes.Default/ScrollBar.xaml
index edd678ed56..ca308b33c3 100644
--- a/src/Avalonia.Themes.Default/ScrollBar.xaml
+++ b/src/Avalonia.Themes.Default/ScrollBar.xaml
@@ -30,20 +30,7 @@
                                               Classes="repeattrack"
                                               Focusable="False"/>
                             </Track.IncreaseButton>
-                            <Thumb Name="thumb">
-                                <Thumb.Styles>
-                                    <Style Selector="Thumb">
-                                        <Setter Property="Background" Value="{DynamicResource ThemeControlHighBrush}"/>
-                                        <Setter Property="Template">
-                                            <Setter.Value>
-                                                <ControlTemplate>
-                                                    <Border Background="{TemplateBinding Background}"/>
-                                                </ControlTemplate>
-                                            </Setter.Value>
-                                        </Setter>
-                                    </Style>
-                                </Thumb.Styles>
-                            </Thumb>
+                            <Thumb Name="thumb"/>
                         </Track>
                         <RepeatButton Name="PART_LineDownButton"
                                       Classes="repeat"
@@ -91,20 +78,7 @@
                                               Classes="repeattrack"
                                               Focusable="False"/>
                             </Track.IncreaseButton>
-                            <Thumb Name="thumb">
-                                <Thumb.Styles>
-                                    <Style Selector="Thumb">
-                                        <Setter Property="Background" Value="{DynamicResource ThemeControlHighBrush}"/>
-                                        <Setter Property="Template">
-                                            <Setter.Value>
-                                                <ControlTemplate>
-                                                    <Border Background="{TemplateBinding Background}"/>
-                                                </ControlTemplate>
-                                            </Setter.Value>
-                                        </Setter>
-                                    </Style>
-                                </Thumb.Styles>
-                            </Thumb>
+                            <Thumb Name="thumb"/>
                         </Track>
                         <RepeatButton Name="PART_LineDownButton"
                                       Classes="repeat"
@@ -120,6 +94,16 @@
             </ControlTemplate>
         </Setter>
     </Style>
+    <Style Selector="ScrollBar /template/ Thumb#thumb">
+        <Setter Property="Background" Value="{DynamicResource ThemeControlHighBrush}"/>
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate>
+                    <Border Background="{TemplateBinding Background}"/>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style Selector="ScrollBar:horizontal /template/ Thumb#thumb">
         <Setter Property="MinWidth" Value="{DynamicResource ScrollBarThickness}" />
     </Style>

From 4413de463e504b9b29b925102a00aceaf96b746b Mon Sep 17 00:00:00 2001
From: Benedikt Schroeder <benedikt.schroeder@outlook.de>
Date: Tue, 16 Apr 2019 19:14:16 +0200
Subject: [PATCH 07/11] Remove unsupported line caps

---
 src/Avalonia.Controls/Shapes/Shape.cs         |  72 ++++++++++--------
 src/Avalonia.Visuals/Media/BrushExtensions.cs |  10 +--
 src/Avalonia.Visuals/Media/Pen.cs             |  72 ++++++++----------
 src/Avalonia.Visuals/Media/PenLineCap.cs      |   3 +-
 src/Skia/Avalonia.Skia/DrawingContextImpl.cs  |  19 ++---
 .../Avalonia.Direct2D1/PrimitiveExtensions.cs |   8 +-
 .../Avalonia.RenderTests/Shapes/PathTests.cs  |   8 +-
 .../Shapes/PolylineTests.cs                   |   3 +-
 .../Path/Path_With_PenLineCap.expected.png    | Bin 1155 -> 1522 bytes
 .../Path/Path_With_PenLineCap.expected.png    | Bin 1155 -> 1522 bytes
 10 files changed, 90 insertions(+), 105 deletions(-)

diff --git a/src/Avalonia.Controls/Shapes/Shape.cs b/src/Avalonia.Controls/Shapes/Shape.cs
index 57dbeba1cc..499dfb5320 100644
--- a/src/Avalonia.Controls/Shapes/Shape.cs
+++ b/src/Avalonia.Controls/Shapes/Shape.cs
@@ -21,13 +21,19 @@ namespace Avalonia.Controls.Shapes
 
         public static readonly StyledProperty<AvaloniaList<double>> StrokeDashArrayProperty =
             AvaloniaProperty.Register<Shape, AvaloniaList<double>>(nameof(StrokeDashArray));
-            
+
         public static readonly StyledProperty<double> StrokeDashOffsetProperty =
             AvaloniaProperty.Register<Shape, double>(nameof(StrokeDashOffset));
 
         public static readonly StyledProperty<double> StrokeThicknessProperty =
             AvaloniaProperty.Register<Shape, double>(nameof(StrokeThickness));
 
+        public static readonly StyledProperty<PenLineCap> StrokeLineCapProperty =
+            AvaloniaProperty.Register<Shape, PenLineCap>(nameof(StrokeLineCap), PenLineCap.Flat);
+
+        public static readonly StyledProperty<PenLineJoin> StrokeJoinProperty =
+            AvaloniaProperty.Register<Shape, PenLineJoin>(nameof(StrokeJoin), PenLineJoin.Miter);
+
         private Matrix _transform = Matrix.Identity;
         private Geometry _definingGeometry;
         private Geometry _renderedGeometry;
@@ -36,7 +42,9 @@ namespace Avalonia.Controls.Shapes
         static Shape()
         {
             AffectsMeasure<Shape>(StretchProperty, StrokeThicknessProperty);
-            AffectsRender<Shape>(FillProperty, StrokeProperty, StrokeDashArrayProperty);
+
+            AffectsRender<Shape>(FillProperty, StrokeProperty, StrokeDashArrayProperty, StrokeDashOffsetProperty,
+                StrokeThicknessProperty, StrokeLineCapProperty, StrokeJoinProperty);
         }
 
         public Geometry DefiningGeometry
@@ -106,7 +114,7 @@ namespace Avalonia.Controls.Shapes
             get { return GetValue(StrokeDashArrayProperty); }
             set { SetValue(StrokeDashArrayProperty, value); }
         }
-        
+
         public double StrokeDashOffset
         {
             get { return GetValue(StrokeDashOffsetProperty); }
@@ -119,13 +127,17 @@ namespace Avalonia.Controls.Shapes
             set { SetValue(StrokeThicknessProperty, value); }
         }
 
-        public PenLineCap StrokeDashCap { get; set; } = PenLineCap.Flat;
-
-        public PenLineCap StrokeStartLineCap { get; set; } = PenLineCap.Flat;
-
-        public PenLineCap StrokeEndLineCap { get; set; } = PenLineCap.Flat;
+        public PenLineCap StrokeLineCap
+        {
+            get { return GetValue(StrokeLineCapProperty); }
+            set { SetValue(StrokeLineCapProperty, value); }
+        }
 
-        public PenLineJoin StrokeJoin { get; set; } = PenLineJoin.Miter;
+        public PenLineJoin StrokeJoin
+        {
+            get { return GetValue(StrokeJoinProperty); }
+            set { SetValue(StrokeJoinProperty, value); }
+        }
 
         public override void Render(DrawingContext context)
         {
@@ -133,8 +145,8 @@ namespace Avalonia.Controls.Shapes
 
             if (geometry != null)
             {
-                var pen = new Pen(Stroke, StrokeThickness, new DashStyle(StrokeDashArray, StrokeDashOffset), 
-                    StrokeDashCap, StrokeStartLineCap, StrokeEndLineCap, StrokeJoin);
+                var pen = new Pen(Stroke, StrokeThickness, new DashStyle(StrokeDashArray, StrokeDashOffset),
+                     StrokeLineCap, StrokeJoin);
                 context.DrawGeometry(Fill, pen, geometry);
             }
         }
@@ -169,11 +181,11 @@ namespace Avalonia.Controls.Shapes
 
         protected void InvalidateGeometry()
         {
-            this._renderedGeometry = null;
-            this._definingGeometry = null;
+            _renderedGeometry = null;
+            _definingGeometry = null;
             InvalidateMeasure();
         }
-        
+
         protected override Size MeasureOverride(Size availableSize)
         {
             bool deferCalculateTransform;
@@ -203,10 +215,10 @@ namespace Avalonia.Controls.Shapes
                 return CalculateShapeSizeAndSetTransform(availableSize);
             }
         }
-        
+
         protected override Size ArrangeOverride(Size finalSize)
         {
-            if(_calculateTransformOnArrange)
+            if (_calculateTransformOnArrange)
             {
                 _calculateTransformOnArrange = false;
                 CalculateShapeSizeAndSetTransform(finalSize);
@@ -312,25 +324,25 @@ namespace Avalonia.Controls.Shapes
 
         private static void AffectsGeometryInvalidate(AvaloniaPropertyChangedEventArgs e)
         {
-            var control = e.Sender as Shape;
+            if (!(e.Sender is Shape control))
+            {
+                return;
+            }
 
-            if (control != null)
+            // If the geometry is invalidated when Bounds changes, only invalidate when the Size
+            // portion changes.
+            if (e.Property == BoundsProperty)
             {
-                // If the geometry is invalidated when Bounds changes, only invalidate when the Size
-                // portion changes.
-                if (e.Property == BoundsProperty)
-                {
-                    var oldBounds = (Rect)e.OldValue;
-                    var newBounds = (Rect)e.NewValue;
+                var oldBounds = (Rect)e.OldValue;
+                var newBounds = (Rect)e.NewValue;
 
-                    if (oldBounds.Size == newBounds.Size)
-                    {
-                        return;
-                    }
+                if (oldBounds.Size == newBounds.Size)
+                {
+                    return;
                 }
-
-                control.InvalidateGeometry();
             }
+
+            control.InvalidateGeometry();
         }
     }
 }
diff --git a/src/Avalonia.Visuals/Media/BrushExtensions.cs b/src/Avalonia.Visuals/Media/BrushExtensions.cs
index cd351071dd..522953eb04 100644
--- a/src/Avalonia.Visuals/Media/BrushExtensions.cs
+++ b/src/Avalonia.Visuals/Media/BrushExtensions.cs
@@ -34,16 +34,14 @@ namespace Avalonia.Media
         {
             Contract.Requires<ArgumentNullException>(pen != null);
 
-            var brush = pen?.Brush?.ToImmutable();
-            return pen == null || ReferenceEquals(pen?.Brush, brush) ?
+            var brush = pen.Brush?.ToImmutable();
+            return ReferenceEquals(pen.Brush, brush) ?
                 pen :
                 new Pen(
                     brush,
                     thickness: pen.Thickness,
-                    dashStyle: pen.DashStyle,
-                    dashCap: pen.DashCap,
-                    startLineCap: pen.StartLineCap,
-                    endLineCap: pen.EndLineCap,
+                    dashStyle: pen.DashStyle,                   
+                    lineCap: pen.LineCap,
                     lineJoin: pen.LineJoin,
                     miterLimit: pen.MiterLimit);
         }
diff --git a/src/Avalonia.Visuals/Media/Pen.cs b/src/Avalonia.Visuals/Media/Pen.cs
index ddd8091801..ee427c913b 100644
--- a/src/Avalonia.Visuals/Media/Pen.cs
+++ b/src/Avalonia.Visuals/Media/Pen.cs
@@ -11,63 +11,45 @@ namespace Avalonia.Media
         /// <summary>
         /// Initializes a new instance of the <see cref="Pen"/> class.
         /// </summary>
-        /// <param name="brush">The brush used to draw.</param>
+        /// <param name="color">The stroke color.</param>
         /// <param name="thickness">The stroke thickness.</param>
         /// <param name="dashStyle">The dash style.</param>
-        /// <param name="dashCap">The dash cap.</param>
-        /// <param name="startLineCap">The start line cap.</param>
-        /// <param name="endLineCap">The end line cap.</param>
+        /// <param name="lineCap">Specifies the type of graphic shape to use on both ends of a line.</param>
         /// <param name="lineJoin">The line join.</param>
         /// <param name="miterLimit">The miter limit.</param>
         public Pen(
-            IBrush brush, 
+            uint color,
             double thickness = 1.0,
-            DashStyle dashStyle = null, 
-            PenLineCap dashCap = PenLineCap.Flat, 
-            PenLineCap startLineCap = PenLineCap.Flat, 
-            PenLineCap endLineCap = PenLineCap.Flat, 
-            PenLineJoin lineJoin = PenLineJoin.Miter, 
-            double miterLimit = 10.0)
+            DashStyle dashStyle = null,
+            PenLineCap lineCap = PenLineCap.Flat,
+            PenLineJoin lineJoin = PenLineJoin.Miter,
+            double miterLimit = 10.0) : this(new SolidColorBrush(color), thickness, dashStyle, lineCap, lineJoin, miterLimit)
         {
-            Brush = brush;
-            Thickness = thickness;
-            DashCap = dashCap;
-            StartLineCap = startLineCap;
-            EndLineCap = endLineCap;
-            LineJoin = lineJoin;
-            MiterLimit = miterLimit;
-            DashStyle = dashStyle;
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="Pen"/> class.
         /// </summary>
-        /// <param name="color">The stroke color.</param>
+        /// <param name="brush">The brush used to draw.</param>
         /// <param name="thickness">The stroke thickness.</param>
         /// <param name="dashStyle">The dash style.</param>
-        /// <param name="dashCap">The dash cap.</param>
-        /// <param name="startLineCap">The start line cap.</param>
-        /// <param name="endLineCap">The end line cap.</param>
+        /// <param name="lineCap">The line cap.</param>
         /// <param name="lineJoin">The line join.</param>
         /// <param name="miterLimit">The miter limit.</param>
         public Pen(
-            uint color, 
+            IBrush brush,
             double thickness = 1.0,
-            DashStyle dashStyle = null, 
-            PenLineCap dashCap = PenLineCap.Flat, 
-            PenLineCap startLineCap = PenLineCap.Flat,
-            PenLineCap endLineCap = PenLineCap.Flat, 
-            PenLineJoin lineJoin = PenLineJoin.Miter, 
+            DashStyle dashStyle = null,
+            PenLineCap lineCap = PenLineCap.Flat,
+            PenLineJoin lineJoin = PenLineJoin.Miter,
             double miterLimit = 10.0)
         {
-            Brush = new SolidColorBrush(color);
+            Brush = brush;
             Thickness = thickness;
-            StartLineCap = startLineCap;
-            EndLineCap = endLineCap;
+            LineCap = lineCap;
             LineJoin = lineJoin;
             MiterLimit = miterLimit;
             DashStyle = dashStyle;
-            DashCap = dashCap;
         }
 
         /// <summary>
@@ -78,18 +60,26 @@ namespace Avalonia.Media
         /// <summary>
         /// Gets the stroke thickness.
         /// </summary>
-        public double Thickness { get; } = 1.0;
+        public double Thickness { get; }
 
+        /// <summary>
+        /// Specifies the style of dashed lines drawn with a <see cref="Pen"/> object.
+        /// </summary>
         public DashStyle DashStyle { get; }
 
-        public PenLineCap DashCap { get; }
-
-        public PenLineCap StartLineCap { get; } = PenLineCap.Flat;
-
-        public PenLineCap EndLineCap { get; } = PenLineCap.Flat;
+        /// <summary>
+        /// Specifies the type of graphic shape to use on both ends of a line.
+        /// </summary>
+        public PenLineCap LineCap { get; }
 
-        public PenLineJoin LineJoin { get; } = PenLineJoin.Miter;
+        /// <summary>
+        /// Specifies how to join consecutive line or curve segments in a <see cref="PathFigure"/> (subpath) contained in a <see cref="PathGeometry"/> object.
+        /// </summary>
+        public PenLineJoin LineJoin { get; }
 
-        public double MiterLimit { get; } = 10.0;
+        /// <summary>
+        /// The limit on the ratio of the miter length to half this pen's Thickness.
+        /// </summary>
+        public double MiterLimit { get; }
     }
 }
diff --git a/src/Avalonia.Visuals/Media/PenLineCap.cs b/src/Avalonia.Visuals/Media/PenLineCap.cs
index 56c5c040eb..83d8f11613 100644
--- a/src/Avalonia.Visuals/Media/PenLineCap.cs
+++ b/src/Avalonia.Visuals/Media/PenLineCap.cs
@@ -4,7 +4,6 @@ namespace Avalonia.Media
     {
         Flat,
         Round,
-        Square,
-        Triangle
+        Square
     }
 }
diff --git a/src/Skia/Avalonia.Skia/DrawingContextImpl.cs b/src/Skia/Avalonia.Skia/DrawingContextImpl.cs
index e69d155305..ef37f69f45 100644
--- a/src/Skia/Avalonia.Skia/DrawingContextImpl.cs
+++ b/src/Skia/Avalonia.Skia/DrawingContextImpl.cs
@@ -573,25 +573,17 @@ namespace Avalonia.Skia
             // Need to modify dashes due to Skia modifying their lengths
             // https://docs.microsoft.com/en-us/xamarin/xamarin-forms/user-interface/graphics/skiasharp/paths/dots
             // TODO: Still something is off, dashes are now present, but don't look the same as D2D ones.
-            float dashLengthModifier;
-            float gapLengthModifier;
 
-            switch (pen.StartLineCap)
+            switch (pen.LineCap)
             {
                 case PenLineCap.Round:
                     paint.StrokeCap = SKStrokeCap.Round;
-                    dashLengthModifier = -paint.StrokeWidth;
-                    gapLengthModifier = paint.StrokeWidth;
                     break;
                 case PenLineCap.Square:
                     paint.StrokeCap = SKStrokeCap.Square;
-                    dashLengthModifier = -paint.StrokeWidth;
-                    gapLengthModifier = paint.StrokeWidth;
                     break;
                 default:
                     paint.StrokeCap = SKStrokeCap.Butt;
-                    dashLengthModifier = 0.0f;
-                    gapLengthModifier = 0.0f;
                     break;
             }
 
@@ -617,13 +609,12 @@ namespace Avalonia.Skia
 
                 for (var i = 0; i < srcDashes.Count; ++i)
                 {
-                    var lengthModifier = i % 2 == 0 ? dashLengthModifier : gapLengthModifier;
-
-                    // Avalonia dash lengths are relative, but Skia takes absolute sizes - need to scale
-                    dashesArray[i] = (float) srcDashes[i] * paint.StrokeWidth + lengthModifier;
+                    dashesArray[i] = (float) srcDashes[i] * paint.StrokeWidth;
                 }
 
-                var pe = SKPathEffect.CreateDash(dashesArray, (float) pen.DashStyle.Offset);
+                var offset = (float)(pen.DashStyle.Offset * pen.Thickness);
+
+                var pe = SKPathEffect.CreateDash(dashesArray, offset);
 
                 paint.PathEffect = pe;
                 rv.AddDisposable(pe);
diff --git a/src/Windows/Avalonia.Direct2D1/PrimitiveExtensions.cs b/src/Windows/Avalonia.Direct2D1/PrimitiveExtensions.cs
index 5209014271..6b0d30f250 100644
--- a/src/Windows/Avalonia.Direct2D1/PrimitiveExtensions.cs
+++ b/src/Windows/Avalonia.Direct2D1/PrimitiveExtensions.cs
@@ -122,14 +122,16 @@ namespace Avalonia.Direct2D1
         /// <returns>The Direct2D brush.</returns>
         public static StrokeStyle ToDirect2DStrokeStyle(this Avalonia.Media.Pen pen, Factory factory)
         {
+            var d2dLineCap = pen.LineCap.ToDirect2D();
+
             var properties = new StrokeStyleProperties
             {
                 DashStyle = DashStyle.Solid,
                 MiterLimit = (float)pen.MiterLimit,
                 LineJoin = pen.LineJoin.ToDirect2D(),
-                StartCap = pen.StartLineCap.ToDirect2D(),
-                EndCap = pen.EndLineCap.ToDirect2D(),
-                DashCap = pen.DashCap.ToDirect2D()
+                StartCap = d2dLineCap,
+                EndCap = d2dLineCap,
+                DashCap = d2dLineCap
             };
             float[] dashes = null;
             if (pen.DashStyle?.Dashes != null && pen.DashStyle.Dashes.Count > 0)
diff --git a/tests/Avalonia.RenderTests/Shapes/PathTests.cs b/tests/Avalonia.RenderTests/Shapes/PathTests.cs
index 4703daca25..2fa93b49e2 100644
--- a/tests/Avalonia.RenderTests/Shapes/PathTests.cs
+++ b/tests/Avalonia.RenderTests/Shapes/PathTests.cs
@@ -334,11 +334,7 @@ namespace Avalonia.Direct2D1.RenderTests.Shapes
             CompareImages();
         }
 
-#if AVALONIA_SKIA_SKIP_FAIL
-        [Fact(Skip = "FIXME")]
-#else
         [Fact]
-#endif
         public async Task Path_With_PenLineCap()
         {
             Decorator target = new Decorator
@@ -351,10 +347,8 @@ namespace Avalonia.Direct2D1.RenderTests.Shapes
                     StrokeThickness = 10,
                     HorizontalAlignment = HorizontalAlignment.Center,
                     VerticalAlignment = VerticalAlignment.Center,
-                    StrokeDashCap = PenLineCap.Triangle,
                     StrokeDashArray = new AvaloniaList<double>(3, 1),
-                    StrokeStartLineCap = PenLineCap.Round,
-                    StrokeEndLineCap = PenLineCap.Square,
+                    StrokeLineCap = PenLineCap.Round,
                     Data = StreamGeometry.Parse("M 20,20 L 180,180"),
                 }
             };
diff --git a/tests/Avalonia.RenderTests/Shapes/PolylineTests.cs b/tests/Avalonia.RenderTests/Shapes/PolylineTests.cs
index 3b586d55ea..8afaeb8838 100644
--- a/tests/Avalonia.RenderTests/Shapes/PolylineTests.cs
+++ b/tests/Avalonia.RenderTests/Shapes/PolylineTests.cs
@@ -61,8 +61,7 @@ namespace Avalonia.Direct2D1.RenderTests.Shapes
                     Points = polylinePoints,
                     Stretch = Stretch.Uniform,
                     StrokeJoin = PenLineJoin.Round,
-                    StrokeStartLineCap = PenLineCap.Round,
-                    StrokeEndLineCap = PenLineCap.Round,
+                    StrokeLineCap = PenLineCap.Round,
                     StrokeThickness = 10
                 }
             };
diff --git a/tests/TestFiles/Direct2D1/Shapes/Path/Path_With_PenLineCap.expected.png b/tests/TestFiles/Direct2D1/Shapes/Path/Path_With_PenLineCap.expected.png
index d33068d62c9deb097896fc29422ed4f765f2daf4..a61ba9f080449b976575ff2faaf7d793aac7e5f9 100644
GIT binary patch
literal 1522
zcmeAS@N?(olHy`uVBq!ia0vp^CqS5k4M?tyST_$yF%}28J29*~C-V}>VM%xNb!1@J
z*w6hZkrl}2EbxddW?<ku48n}Z^H-!WFtE0Jx;TbZ#J#<{u{$PJ<k-WErU)QdcKOgD
zrGzdKCC4>Klsp8uxup*tayqEg>Z;J%+FI`*b<}H{$3&;5)~420g%%DmO{F7F9V!V&
zIJ#e0p62U0yuJ8YT<`3=pKU&DI(Oyw<9j<_*H|(EU4RZw`yH|CjlCWF@B2!LE#Jd(
ztiN49^=U7+VTSg4nZ*{<z6bI|or+!=D6(3ZQ}^lf-avuHoh@bSj=LGYF`anfR9KG4
zp<SIVW}gD{zADz5Ox&=(@7=#W_v^ZBg{teGUwvk@=6G^=S=>Rz>ESIGr!JbM&6(T5
z!ll&M<gq|ONCP|bOz)G!5?c(+CrwYjaA=Olr`7u|9Gl}YuftI~Sox&!&IMC_m3N9;
zi#137TmOE^|LdQuU;T{z`YPsre{%h?dp&!ls*S#RzbWJ4+gmfmdRNhtcSrWcRq9U<
zpIU5~p(y|KUWYDwfuUJfa%JUgwp^M1r|h5poSAsBXHmplkBrQ_Yp=g@ak8F0Pi_AU
zkBp~#Z)miX3UlV#$e!kZy;$Iyugagpj(@E^RR3R_SpUDG5a`1>tUlV6t`f1Dt9DMh
z(1yobFwX)#W}XE0*ouXJ>^Qd=s0*o|x_s)2$EV*PE}WX;aqh^1xxPv}rBB!AJ)C*t
z=8Z=R))@=CRL(#CmH2dT^u`|6s1xoxe{RXLY}!*4(tb5H=7N*msk6&Ne>U3K7eC3p
z`f6&j$;1mmb<ZSN4QF{|Jl}dlqiwI6P?V*lbnAvZrG>rj$w1w(XnUv8lm!&~lPd2T
z;H$Dl5m%(ZTn~&jVEokZM9mOBS*Ej}|9ovx$#?bN@4a;Vy)CzX&NAjdUe{l{@iUjy
zj4IWiHf(EsI#aaS-sVW1wB9&nd-^%XWmB~#NpCFP_<HyH_eb}2&h2yL{;6R;KdkrB
ziM9Lo-(WZVr|Q2^t|tDd-tm7Of5m?5l^K?qZhLp-$MdAh+f)6IFPM8YH+1VB-{!DS
zrwqCh*LSvreOht(;`2$scv@Q{4fP{1>bn-q@=*IA^7_Fq!)e>2fL`wUQ@_{d?xNm3
zN<HgDuEuy~II9E*aEiDvu}*Yw#L7&}Q{ih`(7SV@MNo&?GnYp)2~jhpPR^CsVx&6B
zX0PC_n<kTNbQbltm(@F+@(^oJeE;<BjpU8#$v@}*c%MA~&A%3Befg(->tuG?aQ}FA
zs(Po*;@5vAwoK?R+TR07cH2WMQzegX+_Q(t(Yvx$!gZt7#0!^}-q7f{2uy^Pr%j>$
z6R(3rm*0_P^EBpLUzlhyd%EvmnbYw<#LMDx&qW^CV)Q&r`*~Tn86MBTyx6*P;+$Sb
z?qa2#qQFcf_RM9{{j?UdWo|`kpvZc%^2WXob4$K?*SXv7Up?=BWW4(MKYw+;1-+Si
z<KvCDH`W_kd|9P^GEAr6KDO?C-kY~z|9sB8TEucaN%Huo>eZ)rENK0+T*U8~(KKMj
zir!n)15A8Xwq{&Oz+`#uCp0zAEMkrHQQ0!FzZj?&lF6Pdz7xoD)x}Br=V?1o<l&8<
zXKqD`Y`SMUQ>?>e<rv$61%%$w1-&aL-sy4F4purD916@t$~$G6r<rv=DdD+w3Y=v`
z+~+M|di!+ootmhr@+UqUyWb1jSp+N)4>Z3&F>ybmVM^c+PM3FOpd!-K)z4*}Q$iB}
Dt%9q!

literal 1155
zcmeAS@N?(olHy`uVBq!ia0vp^CqS5k4M?tyST_$yF%}28J29*~C-V}>VM%xNb!1@J
z*w6hZkrl|*^>lFzsfc@fcVS*?s6^XCKHq>2FBQJ-H3}`=2Odm_kdbq4YOq#d;WQ6u
zeaIKUa*%^XsIi&l+Wq2LCU3L$Z#AF0<xBm%C#UbFU)uFKZL7L*wI9$HbnswT`LTVn
zzhCayWiQ|S%}(xj_M7?AtL=a1@Z4H8Ia%!Z*IG+9-K+gUn>F(MRJMfd&p*>N!&ha?
z=hHWI+IFi6Mg7dn5j#{X%$a+|edo*RUv9b_T5M$-7r*uXu{ina_n)rr;(DF)=Fuln
zo8nTXGk#qr>YTY9EKCy}6ofcjm>NA41UOlg8XZ&w5P}EqdDw6?nSFElbXa1`MpL22
z3+JYJusC_Ip2*R%Elf#}W9?E8mP7U59##C^zpB6JzU`fRpNihhKKxd<zW;B<j@Ehi
z<Y&*-312PDam%amii=aUHi-0I4I-_hnO1hTgl%IB0=fA3{>>bhT%4r8rp<SqpeA$+
z(=F%@++Z%0k?gN>;nX#c1#@*LIshHz5UoAYAzM@Ef!yYdbzy~$*_#d4`KxR(>wfeM
zX!mA?G+|ENvq?L$l@`v8<oFH@I-_m{UlsowFF&3-Y$0uJe@Aci`t|R3@2FutA2XL@
z^JJy7o=(zeL4xUwN&LqawAxOrF=5Ni>2*=qvRM@vPM5M&m=>;`3Jffudm8s7>Gy@t
zTlY)jdoM6-^85Ez?%4bE`Ns47+b>+cp1gVT)2vb^$7sz7vph1gRY7E?DTqw>Rxq6i
z^q@nQ(!yT<<7t9RI$O+MowWnGdW#~?Sc5pRT6yJuTOQpvolE}x<-`?vw^$$D+;b;H
z{^>R2`t&;a)#?Av{jvP^_n}zTs^uro`%PPYm6IiRDaih{Q$gg?s~~c&E+_)EqnUvb
zX!dG<^K5XGtuX(s(_}L7LL0V}gcNLVdY^O~W+eKn?C*1wj#d`rc$?D+47M#&oen_X
z1H&$=>&Zptk2!I2(X~^e`I~2~OlPdG*fF=Na*vaDe(zbLT=k75sCt8kUw?Q-*FOns
zY3uzpTi5N|x9>et^0&{sNXV%+9xCf)*MGQEWAyFnL$MvFr%gW6AF*YNP^U%4+kGBK
v7!T_R6&^6Xt}Mvz6C&}5fuVv&UHw1P$(b*Hr<rds0_AT{S3j3^P6<r_*89)%

diff --git a/tests/TestFiles/Skia/Shapes/Path/Path_With_PenLineCap.expected.png b/tests/TestFiles/Skia/Shapes/Path/Path_With_PenLineCap.expected.png
index d33068d62c9deb097896fc29422ed4f765f2daf4..a61ba9f080449b976575ff2faaf7d793aac7e5f9 100644
GIT binary patch
literal 1522
zcmeAS@N?(olHy`uVBq!ia0vp^CqS5k4M?tyST_$yF%}28J29*~C-V}>VM%xNb!1@J
z*w6hZkrl}2EbxddW?<ku48n}Z^H-!WFtE0Jx;TbZ#J#<{u{$PJ<k-WErU)QdcKOgD
zrGzdKCC4>Klsp8uxup*tayqEg>Z;J%+FI`*b<}H{$3&;5)~420g%%DmO{F7F9V!V&
zIJ#e0p62U0yuJ8YT<`3=pKU&DI(Oyw<9j<_*H|(EU4RZw`yH|CjlCWF@B2!LE#Jd(
ztiN49^=U7+VTSg4nZ*{<z6bI|or+!=D6(3ZQ}^lf-avuHoh@bSj=LGYF`anfR9KG4
zp<SIVW}gD{zADz5Ox&=(@7=#W_v^ZBg{teGUwvk@=6G^=S=>Rz>ESIGr!JbM&6(T5
z!ll&M<gq|ONCP|bOz)G!5?c(+CrwYjaA=Olr`7u|9Gl}YuftI~Sox&!&IMC_m3N9;
zi#137TmOE^|LdQuU;T{z`YPsre{%h?dp&!ls*S#RzbWJ4+gmfmdRNhtcSrWcRq9U<
zpIU5~p(y|KUWYDwfuUJfa%JUgwp^M1r|h5poSAsBXHmplkBrQ_Yp=g@ak8F0Pi_AU
zkBp~#Z)miX3UlV#$e!kZy;$Iyugagpj(@E^RR3R_SpUDG5a`1>tUlV6t`f1Dt9DMh
z(1yobFwX)#W}XE0*ouXJ>^Qd=s0*o|x_s)2$EV*PE}WX;aqh^1xxPv}rBB!AJ)C*t
z=8Z=R))@=CRL(#CmH2dT^u`|6s1xoxe{RXLY}!*4(tb5H=7N*msk6&Ne>U3K7eC3p
z`f6&j$;1mmb<ZSN4QF{|Jl}dlqiwI6P?V*lbnAvZrG>rj$w1w(XnUv8lm!&~lPd2T
z;H$Dl5m%(ZTn~&jVEokZM9mOBS*Ej}|9ovx$#?bN@4a;Vy)CzX&NAjdUe{l{@iUjy
zj4IWiHf(EsI#aaS-sVW1wB9&nd-^%XWmB~#NpCFP_<HyH_eb}2&h2yL{;6R;KdkrB
ziM9Lo-(WZVr|Q2^t|tDd-tm7Of5m?5l^K?qZhLp-$MdAh+f)6IFPM8YH+1VB-{!DS
zrwqCh*LSvreOht(;`2$scv@Q{4fP{1>bn-q@=*IA^7_Fq!)e>2fL`wUQ@_{d?xNm3
zN<HgDuEuy~II9E*aEiDvu}*Yw#L7&}Q{ih`(7SV@MNo&?GnYp)2~jhpPR^CsVx&6B
zX0PC_n<kTNbQbltm(@F+@(^oJeE;<BjpU8#$v@}*c%MA~&A%3Befg(->tuG?aQ}FA
zs(Po*;@5vAwoK?R+TR07cH2WMQzegX+_Q(t(Yvx$!gZt7#0!^}-q7f{2uy^Pr%j>$
z6R(3rm*0_P^EBpLUzlhyd%EvmnbYw<#LMDx&qW^CV)Q&r`*~Tn86MBTyx6*P;+$Sb
z?qa2#qQFcf_RM9{{j?UdWo|`kpvZc%^2WXob4$K?*SXv7Up?=BWW4(MKYw+;1-+Si
z<KvCDH`W_kd|9P^GEAr6KDO?C-kY~z|9sB8TEucaN%Huo>eZ)rENK0+T*U8~(KKMj
zir!n)15A8Xwq{&Oz+`#uCp0zAEMkrHQQ0!FzZj?&lF6Pdz7xoD)x}Br=V?1o<l&8<
zXKqD`Y`SMUQ>?>e<rv$61%%$w1-&aL-sy4F4purD916@t$~$G6r<rv=DdD+w3Y=v`
z+~+M|di!+ootmhr@+UqUyWb1jSp+N)4>Z3&F>ybmVM^c+PM3FOpd!-K)z4*}Q$iB}
Dt%9q!

literal 1155
zcmeAS@N?(olHy`uVBq!ia0vp^CqS5k4M?tyST_$yF%}28J29*~C-V}>VM%xNb!1@J
z*w6hZkrl|*^>lFzsfc@fcVS*?s6^XCKHq>2FBQJ-H3}`=2Odm_kdbq4YOq#d;WQ6u
zeaIKUa*%^XsIi&l+Wq2LCU3L$Z#AF0<xBm%C#UbFU)uFKZL7L*wI9$HbnswT`LTVn
zzhCayWiQ|S%}(xj_M7?AtL=a1@Z4H8Ia%!Z*IG+9-K+gUn>F(MRJMfd&p*>N!&ha?
z=hHWI+IFi6Mg7dn5j#{X%$a+|edo*RUv9b_T5M$-7r*uXu{ina_n)rr;(DF)=Fuln
zo8nTXGk#qr>YTY9EKCy}6ofcjm>NA41UOlg8XZ&w5P}EqdDw6?nSFElbXa1`MpL22
z3+JYJusC_Ip2*R%Elf#}W9?E8mP7U59##C^zpB6JzU`fRpNihhKKxd<zW;B<j@Ehi
z<Y&*-312PDam%amii=aUHi-0I4I-_hnO1hTgl%IB0=fA3{>>bhT%4r8rp<SqpeA$+
z(=F%@++Z%0k?gN>;nX#c1#@*LIshHz5UoAYAzM@Ef!yYdbzy~$*_#d4`KxR(>wfeM
zX!mA?G+|ENvq?L$l@`v8<oFH@I-_m{UlsowFF&3-Y$0uJe@Aci`t|R3@2FutA2XL@
z^JJy7o=(zeL4xUwN&LqawAxOrF=5Ni>2*=qvRM@vPM5M&m=>;`3Jffudm8s7>Gy@t
zTlY)jdoM6-^85Ez?%4bE`Ns47+b>+cp1gVT)2vb^$7sz7vph1gRY7E?DTqw>Rxq6i
z^q@nQ(!yT<<7t9RI$O+MowWnGdW#~?Sc5pRT6yJuTOQpvolE}x<-`?vw^$$D+;b;H
z{^>R2`t&;a)#?Av{jvP^_n}zTs^uro`%PPYm6IiRDaih{Q$gg?s~~c&E+_)EqnUvb
zX!dG<^K5XGtuX(s(_}L7LL0V}gcNLVdY^O~W+eKn?C*1wj#d`rc$?D+47M#&oen_X
z1H&$=>&Zptk2!I2(X~^e`I~2~OlPdG*fF=Na*vaDe(zbLT=k75sCt8kUw?Q-*FOns
zY3uzpTi5N|x9>et^0&{sNXV%+9xCf)*MGQEWAyFnL$MvFr%gW6AF*YNP^U%4+kGBK
v7!T_R6&^6Xt}Mvz6C&}5fuVv&UHw1P$(b*Hr<rds0_AT{S3j3^P6<r_*89)%


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 08/11] 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 9f16acbcc67d94c2fd7ff0628fec89325e158007 Mon Sep 17 00:00:00 2001
From: DanTheMan827 <790119+DanTheMan827@users.noreply.github.com>
Date: Sat, 27 Apr 2019 00:32:53 -0500
Subject: [PATCH 09/11] Fix url encoded path and filenames on Mac

#2475
---
 native/Avalonia.Native/src/OSX/SystemDialogs.mm | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/native/Avalonia.Native/src/OSX/SystemDialogs.mm b/native/Avalonia.Native/src/OSX/SystemDialogs.mm
index 7049f77d20..567dd7f747 100644
--- a/native/Avalonia.Native/src/OSX/SystemDialogs.mm
+++ b/native/Avalonia.Native/src/OSX/SystemDialogs.mm
@@ -45,8 +45,7 @@ public:
                         {
                             auto url = [urls objectAtIndex:i];
                             
-                            auto string = [url absoluteString];
-                            string = [string substringFromIndex:7];
+                            auto string = [url path];
                             
                             strings[i] = (void*)[string UTF8String];
                         }
@@ -137,8 +136,7 @@ public:
                         {
                             auto url = [urls objectAtIndex:i];
                             
-                            auto string = [url absoluteString];
-                            string = [string substringFromIndex:7];
+                            auto string = [url path];
                             
                             strings[i] = (void*)[string UTF8String];
                         }
@@ -220,8 +218,7 @@ public:
                     
                     auto url = [panel URL];
                     
-                    auto string = [url absoluteString];
-                    string = [string substringFromIndex:7];     
+                    auto string = [url path];   
                     strings[0] = (void*)[string UTF8String];
                
                     events->OnCompleted(1, &strings[0]);

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 10/11] 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 11/11] 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()
             {