From 9fa1ab92827d43895d3cb0241457dcaef5db7af7 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Mon, 6 Apr 2020 22:48:07 +0200
Subject: [PATCH 01/32] Add failing tests for shared context menus.

Tests for #497.
---
 .../ContextMenuTests.cs                       | 87 +++++++++++++++++++
 1 file changed, 87 insertions(+)

diff --git a/tests/Avalonia.Controls.UnitTests/ContextMenuTests.cs b/tests/Avalonia.Controls.UnitTests/ContextMenuTests.cs
index 5a47a86e51..a54b93cfff 100644
--- a/tests/Avalonia.Controls.UnitTests/ContextMenuTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ContextMenuTests.cs
@@ -1,7 +1,10 @@
 using System;
 using Avalonia.Input;
+using Avalonia.Markup.Xaml;
+using Avalonia.Markup.Xaml.MarkupExtensions;
 using Avalonia.Platform;
 using Avalonia.UnitTests;
+using Castle.DynamicProxy.Generators;
 using Moq;
 using Xunit;
 
@@ -168,6 +171,90 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void Context_Menu_In_Resources_Can_Be_Shared()
+        {
+            using (Application())
+            {
+                var xaml = @"
+<Window xmlns='https://github.com/avaloniaui'
+        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
+    <Window.Resources>
+        <ContextMenu x:Key='contextMenu'>
+            <MenuItem>Foo</MenuItem>
+        </ContextMenu>
+	</Window.Resources>
+
+    <StackPanel>
+        <TextBlock Name='target1' ContextMenu='{StaticResource contextMenu}'/>
+        <TextBlock Name='target2' ContextMenu='{StaticResource contextMenu}'/>
+    </StackPanel>
+</Window>";
+
+                var loader = new AvaloniaXamlLoader();
+                var window = (Window)loader.Load(xaml);
+                var target1 = window.Find<TextBlock>("target1");
+                var target2 = window.Find<TextBlock>("target2");
+                var mouse = new MouseTestHelper();
+
+                Assert.NotNull(target1.ContextMenu);
+                Assert.NotNull(target2.ContextMenu);
+                Assert.Same(target1.ContextMenu, target2.ContextMenu);
+
+                window.Show();
+
+                var menu = target1.ContextMenu;
+                mouse.Click(target1, MouseButton.Right);
+                Assert.True(menu.IsOpen);
+                mouse.Click(target2, MouseButton.Right);
+                Assert.True(menu.IsOpen);
+            }
+        }
+
+        [Fact]
+        public void Context_Menu_Can_Be_Set_In_Style()
+        {
+            using (Application())
+            {
+                var xaml = @"
+<Window xmlns='https://github.com/avaloniaui'
+        xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'>
+    <Window.Styles>
+        <Style Selector='TextBlock'>
+            <Setter Property='ContextMenu'>
+                <ContextMenu>
+                    <MenuItem>Foo</MenuItem>
+                </ContextMenu>
+            </Setter>
+        </Style>
+	</Window.Styles>
+
+    <StackPanel>
+        <TextBlock Name='target1'/>
+        <TextBlock Name='target2'/>
+    </StackPanel>
+</Window>";
+
+                var loader = new AvaloniaXamlLoader();
+                var window = (Window)loader.Load(xaml);
+                var target1 = window.Find<TextBlock>("target1");
+                var target2 = window.Find<TextBlock>("target2");
+                var mouse = new MouseTestHelper();
+
+                Assert.NotNull(target1.ContextMenu);
+                Assert.NotNull(target2.ContextMenu);
+                Assert.Same(target1.ContextMenu, target2.ContextMenu);
+
+                window.Show();
+
+                var menu = target1.ContextMenu;
+                mouse.Click(target1, MouseButton.Right);
+                Assert.True(menu.IsOpen);
+                mouse.Click(target2, MouseButton.Right);
+                Assert.True(menu.IsOpen);
+            }
+        }
+
         [Fact(Skip = "The only reason this test was 'passing' before was that the author forgot to call Window.ApplyTemplate()")]
         public void Cancelling_Closing_Leaves_ContextMenuOpen()
         {

From 204894854120d9b3fa898906ffd74202ccc7a05a Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Mon, 6 Apr 2020 22:48:25 +0200
Subject: [PATCH 02/32] Allow context menus to be shared.

Either via resources or styles.
---
 src/Avalonia.Controls/ContextMenu.cs | 39 ++++++++++++++++++++++------
 1 file changed, 31 insertions(+), 8 deletions(-)

diff --git a/src/Avalonia.Controls/ContextMenu.cs b/src/Avalonia.Controls/ContextMenu.cs
index 1735599988..86499530da 100644
--- a/src/Avalonia.Controls/ContextMenu.cs
+++ b/src/Avalonia.Controls/ContextMenu.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
 using Avalonia.Controls.Generators;
@@ -9,18 +10,19 @@ using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Layout;
 using Avalonia.LogicalTree;
+using Avalonia.Styling;
 
 namespace Avalonia.Controls
 {
     /// <summary>
     /// A control context menu.
     /// </summary>
-    public class ContextMenu : MenuBase
+    public class ContextMenu : MenuBase, ISetterValue
     {
         private static readonly ITemplate<IPanel> DefaultPanel =
             new FuncTemplate<IPanel>(() => new StackPanel { Orientation = Orientation.Vertical });
         private Popup _popup;
-        private Control _attachedControl;
+        private List<Control> _attachedControls;
         private IInputElement _previousFocus;
 
         /// <summary>
@@ -74,13 +76,14 @@ namespace Avalonia.Controls
             if (e.OldValue is ContextMenu oldMenu)
             {
                 control.PointerReleased -= ControlPointerReleased;
-                oldMenu._attachedControl = null;
+                oldMenu._attachedControls?.Remove(control);
                 ((ISetLogicalParent)oldMenu._popup)?.SetParent(null);
             }
 
             if (e.NewValue is ContextMenu newMenu)
             {
-                newMenu._attachedControl = control;
+                newMenu._attachedControls ??= new List<Control>();
+                newMenu._attachedControls.Add(control);
                 control.PointerReleased += ControlPointerReleased;
             }
         }
@@ -96,18 +99,22 @@ namespace Avalonia.Controls
         /// <param name="control">The control.</param>
         public void Open(Control control)
         {
-            if (control is null && _attachedControl is null)
+            if (control is null && (_attachedControls is null || _attachedControls.Count == 0))
             {
                 throw new ArgumentNullException(nameof(control));
             }
 
-            if (control is object && _attachedControl is object && control != _attachedControl)
+            if (control is object &&
+                _attachedControls is object &&
+                !_attachedControls.Contains(control))
             {
                 throw new ArgumentException(
                     "Cannot show ContentMenu on a different control to the one it is attached to.",
                     nameof(control));
             }
 
+            control ??= _attachedControls[0];
+
             if (IsOpen)
             {
                 return;
@@ -126,7 +133,12 @@ namespace Avalonia.Controls
                 _popup.Closed += PopupClosed;
             }
 
-            ((ISetLogicalParent)_popup).SetParent(control);
+            if (_popup.Parent != control)
+            {
+                ((ISetLogicalParent)_popup).SetParent(null);
+                ((ISetLogicalParent)_popup).SetParent(control);
+            }
+
             _popup.Child = this;
             _popup.IsOpen = true;
 
@@ -155,6 +167,17 @@ namespace Avalonia.Controls
             }
         }
 
+        void ISetterValue.Initialize(ISetter setter)
+        {
+            // ContextMenu can be assigned to the ContextMenu property in a setter. This overrides
+            // the behavior defined in Control which requires controls to be wrapped in a <template>.
+            if (!(setter is Setter s && s.Property == ContextMenuProperty))
+            {
+                throw new InvalidOperationException(
+                    "Cannot use a control as a Setter value. Wrap the control in a <Template>.");
+            }
+        }
+
         protected override IItemContainerGenerator CreateItemContainerGenerator()
         {
             return new MenuItemContainerGenerator(this);
@@ -179,7 +202,7 @@ namespace Avalonia.Controls
             SelectedIndex = -1;
             IsOpen = false;
 
-            if (_attachedControl is null)
+            if (_attachedControls is null || _attachedControls.Count == 0)
             {
                 ((ISetLogicalParent)_popup).SetParent(null);
             }

From 40f04c257f05a11bbe867990eb87e2255dc42790 Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Fri, 8 May 2020 20:17:50 -0300
Subject: [PATCH 03/32] Add render demo showing the algoritm to calculate
 bounds for lines.

---
 samples/ControlCatalog/MainWindow.xaml    |  69 +----------
 samples/ControlCatalog/MainWindow.xaml.cs | 136 +++++++++++++++++-----
 2 files changed, 112 insertions(+), 93 deletions(-)

diff --git a/samples/ControlCatalog/MainWindow.xaml b/samples/ControlCatalog/MainWindow.xaml
index 935db20757..117ddb8262 100644
--- a/samples/ControlCatalog/MainWindow.xaml
+++ b/samples/ControlCatalog/MainWindow.xaml
@@ -9,68 +9,11 @@
         xmlns:v="clr-namespace:ControlCatalog.Views"
         x:Class="ControlCatalog.MainWindow" WindowState="{Binding WindowState, Mode=TwoWay}">
 
-  <NativeMenu.Menu>
-    <NativeMenu>
-      <NativeMenuItem Header="File">
-        <NativeMenuItem.Menu>
-          <NativeMenu>
-            <NativeMenuItem Icon="/Assets/test_icon.ico" Header="Open" Clicked="OnOpenClicked" Gesture="Ctrl+O"/>
-            <NativeMenuItemSeperator/>
-            <NativeMenuItem Icon="/Assets/github_icon.png" Header="Recent">
-              <NativeMenuItem.Menu>
-                <NativeMenu/>
-              </NativeMenuItem.Menu>
-            </NativeMenuItem>
-            <NativeMenuItemSeperator/>
-            <NativeMenuItem Header="{x:Static local:MainWindow.MenuQuitHeader}"
-                            Gesture="{x:Static local:MainWindow.MenuQuitGesture}"
-                            Clicked="OnCloseClicked" />
-          </NativeMenu>
-        </NativeMenuItem.Menu>
-      </NativeMenuItem>
-      <NativeMenuItem Header="Edit">
-        <NativeMenuItem.Menu>
-          <NativeMenu>
-            <NativeMenuItem Header="Copy"/>
-            <NativeMenuItem Header="Paste"/>
-          </NativeMenu>
-        </NativeMenuItem.Menu>
-      </NativeMenuItem>
-      <NativeMenuItem Header="Options">
-        <NativeMenuItem.Menu>
-          <NativeMenu>
-           <NativeMenuItem Header="Check Me (None)" 
-                            Command="{Binding ToggleMenuItemCheckedCommand}"
-                            ToggleType="None"
-                            IsChecked="{Binding IsMenuItemChecked}"  />
-            <NativeMenuItem Header="Check Me (CheckBox)" 
-                            Command="{Binding ToggleMenuItemCheckedCommand}"
-                            ToggleType="CheckBox"
-                            IsChecked="{Binding IsMenuItemChecked}"  />
-            <NativeMenuItem Header="Check Me (Radio)" 
-                            Command="{Binding ToggleMenuItemCheckedCommand}"
-                            ToggleType="Radio"
-                            IsChecked="{Binding IsMenuItemChecked}"  />
-          </NativeMenu>
-        </NativeMenuItem.Menu>
-      </NativeMenuItem>
-    </NativeMenu>
-  </NativeMenu.Menu>
-
- <Window.DataTemplates>
-    <DataTemplate DataType="vm:NotificationViewModel">
-      <v:CustomNotificationView />
-    </DataTemplate>
-  </Window.DataTemplates>
-  <DockPanel LastChildFill="True">
-    <Menu Name="MainMenu" DockPanel.Dock="Top">
-      <MenuItem Header="File">
-        <MenuItem Header="Exit" Command="{Binding ExitCommand}" />
-      </MenuItem>
-      <MenuItem Header="Help">
-        <MenuItem Header="About" Command="{Binding AboutCommand}" />
-      </MenuItem>
-    </Menu>
-    <local:MainView />
+  <DockPanel>
+    <StackPanel DockPanel.Dock="Top">
+      <Button Content="Test" />
+      <local:TestControl1 VerticalAlignment="Stretch" Height="20" />
+    </StackPanel>
+    <local:TestControl />
   </DockPanel>
 </Window>
diff --git a/samples/ControlCatalog/MainWindow.xaml.cs b/samples/ControlCatalog/MainWindow.xaml.cs
index d97325ef8d..954a76a4f9 100644
--- a/samples/ControlCatalog/MainWindow.xaml.cs
+++ b/samples/ControlCatalog/MainWindow.xaml.cs
@@ -1,61 +1,137 @@
 using System;
-using System.Runtime.InteropServices;
 using Avalonia;
 using Avalonia.Controls;
-using Avalonia.Controls.Notifications;
-using Avalonia.Input;
 using Avalonia.Markup.Xaml;
-using ControlCatalog.ViewModels;
+using Avalonia.Media;
+using Avalonia.Threading;
 
 namespace ControlCatalog
 {
-    public class MainWindow : Window
+    public class TestControl : Control
     {
-        private WindowNotificationManager _notificationArea;
-        private NativeMenu _recentMenu;
+        private Random _r = new Random();
 
-        public MainWindow()
+        private double angle = 45;
+        public TestControl()
         {
-            this.InitializeComponent();
-            this.AttachDevTools();
-            //Renderer.DrawFps = true;
-            //Renderer.DrawDirtyRects = Renderer.DrawFps = true;
+            DispatcherTimer t = new DispatcherTimer();
+            t.Interval = TimeSpan.FromSeconds(0.0125);
 
-            _notificationArea = new WindowNotificationManager(this)
+            t.Tick += (sender, e) =>
             {
-                Position = NotificationPosition.TopRight,
-                MaxItems = 3
+                angle += 1;
+               Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
             };
 
-            DataContext = new MainWindowViewModel(_notificationArea);
-            _recentMenu = ((NativeMenu.GetMenu(this).Items[0] as NativeMenuItem).Menu.Items[2] as NativeMenuItem).Menu;
+            t.Start();
+        }
+
+        const double degreeToRadians = Math.PI / 180.0;
+
+        private static double CalculateAngle(Point p1, Point p2)
+        {
+            var xDiff = p2.X - p1.X;
+            var yDiff = p2.Y - p1.Y;
+
+            return Math.Atan2(yDiff, xDiff) * 180.0 / Math.PI;
+        }
+
+        private static double CalculateOppSide(double angle, double hyp)
+        {
+            return Math.Sin(angle * degreeToRadians) * hyp;
+        }
+
+        private static double CalculateAdjSide(double angle, double hyp)
+        {   
+            return Math.Cos(angle * degreeToRadians) * hyp;
+        }
 
-            var mainMenu = this.FindControl<Menu>("MainMenu");
-            mainMenu.AttachedToVisualTree += MenuAttached;
+        static Rect CalculateBounds(Point p1, Point p2, double thickness, double angleToCorner)
+        {
+            var pts = TranslatePointsAlongTangent(p1, p2, angleToCorner + 90, thickness / 2);
+
+            return new Rect(pts.p1, pts.p2);
         }
+        
+        static (Point p1, Point p2) TranslatePointsAlongTangent(Point p1, Point p2, double angle, double distance)
+        {
+            var xDiff = CalculateOppSide(angle, distance);
+            var yDiff = CalculateAdjSide(angle, distance);            
 
-        public static string MenuQuitHeader => RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ? "Quit Avalonia" : "E_xit";
+            var c1 = new Point(p1.X + xDiff, p1.Y - yDiff);
+            var c2 = new Point(p1.X - xDiff, p1.Y + yDiff);
 
-        public static KeyGesture MenuQuitGesture => RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ?
-            new KeyGesture(Key.Q, KeyModifiers.Meta) :
-            new KeyGesture(Key.F4, KeyModifiers.Alt);
+            var c3 = new Point(p2.X + xDiff, p2.Y - yDiff);
+            var c4 = new Point(p2.X - xDiff, p2.Y + yDiff);
 
-        public void MenuAttached(object sender, VisualTreeAttachmentEventArgs e)
+            var minX = Math.Min(c1.X, Math.Min(c2.X, Math.Min(c3.X, c4.X)));
+            var minY = Math.Min(c1.Y, Math.Min(c2.Y, Math.Min(c3.Y, c4.Y)));
+            var maxX = Math.Max(c1.X, Math.Max(c2.X, Math.Max(c3.X, c4.X)));
+            var maxY = Math.Max(c1.Y, Math.Max(c2.Y, Math.Max(c3.Y, c4.Y)));
+
+            return (new Point(minX, minY), new Point(maxX, maxY));            
+        }
+
+        static Rect CalculateBounds (Point p1, Point p2, Pen p)
         {
-            if (NativeMenu.GetIsNativeMenuExported(this) && sender is Menu mainMenu)
+            var angle = CalculateAngle(p1, p2);
+
+            var angleToCorner = 90 - angle;
+
+            if (p.LineCap != PenLineCap.Flat)
             {
-                mainMenu.IsVisible = false;
+                var pts = TranslatePointsAlongTangent(p1, p2, angleToCorner, p.Thickness / 2);
+
+                return CalculateBounds(pts.p1, pts.p2, p.Thickness, angleToCorner);
+            }
+            else
+            {
+                return CalculateBounds(p1, p2, p.Thickness, angleToCorner);
             }
         }
 
-        public void OnOpenClicked(object sender, EventArgs args)
+        
+
+        public override void Render(DrawingContext drawingContext)
+        {
+            var lineLength = Math.Sqrt((100 * 100) + (100 * 100));
+
+            var diffX = CalculateAdjSide(angle, lineLength);
+            var diffY = CalculateOppSide(angle, lineLength);            
+
+
+            var p1 = new Point(400, 400);
+            var p2 = new Point(p1.X + diffX, p1.Y + diffY);
+
+            var pen = new Pen(Brushes.Green, 20, lineCap: PenLineCap.Round);
+            var boundPen = new Pen(Brushes.Black);
+
+            drawingContext.DrawLine(pen, p1, p2);
+
+            drawingContext.DrawRectangle(boundPen, CalculateBounds(p1, p2, pen));
+
+            //Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
+        }
+    }
+
+    public class TestControl1 : Control
+    {
+        private Random _r = new Random();
+
+        public override void Render(DrawingContext drawingContext)
         {
-            _recentMenu.Items.Insert(0, new NativeMenuItem("Item " + (_recentMenu.Items.Count + 1)));
+            drawingContext.FillRectangle(Brushes.Red, Bounds);
         }
+    }
 
-        public void OnCloseClicked(object sender, EventArgs args)
+    /// <summary>
+    /// Interaction logic for MainWindow.xaml
+    /// </summary>
+    public partial class MainWindow : Window
+    {
+        public MainWindow()
         {
-            Close();
+            InitializeComponent();
         }
 
         private void InitializeComponent()

From 1dc40aad68eddb432407826d845a7691961a5635 Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Fri, 8 May 2020 20:20:06 -0300
Subject: [PATCH 04/32] dont inflate in draw operation

---
 src/Avalonia.Visuals/Rendering/SceneGraph/DrawOperation.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/DrawOperation.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/DrawOperation.cs
index d9dfd8bd55..983a785577 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/DrawOperation.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/DrawOperation.cs
@@ -11,7 +11,7 @@ namespace Avalonia.Rendering.SceneGraph
     {
         public DrawOperation(Rect bounds, Matrix transform, IPen pen)
         {
-            bounds = bounds.Inflate((pen?.Thickness ?? 0) / 2).TransformToAABB(transform);
+            bounds = bounds.TransformToAABB(transform);
             Bounds = new Rect(
                 new Point(Math.Floor(bounds.X), Math.Floor(bounds.Y)),
                 new Point(Math.Ceiling(bounds.Right), Math.Ceiling(bounds.Bottom)));

From b429f3e850cd049f8429fc41fae629d7f2543558 Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Fri, 8 May 2020 20:20:24 -0300
Subject: [PATCH 05/32] move calculate bounds to LineNode.

---
 .../Rendering/SceneGraph/LineNode.cs          | 76 ++++++++++++++++++-
 1 file changed, 74 insertions(+), 2 deletions(-)

diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs
index f00f23e08b..1ff7aa8618 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs
@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using Avalonia.Media;
 using Avalonia.Media.Immutable;
 using Avalonia.Platform;
@@ -6,11 +7,78 @@ using Avalonia.VisualTree;
 
 namespace Avalonia.Rendering.SceneGraph
 {
+
     /// <summary>
     /// A node in the scene graph which represents a line draw.
     /// </summary>
     internal class LineNode : BrushDrawOperation
     {
+
+        const double degreeToRadians = Math.PI / 180.0;
+
+        private static double CalculateAngle(Point p1, Point p2)
+        {
+            var xDiff = p2.X - p1.X;
+            var yDiff = p2.Y - p1.Y;
+
+            return Math.Atan2(yDiff, xDiff) * 180.0 / Math.PI;
+        }
+
+        private static double CalculateOppSide(double angle, double hyp)
+        {
+            return Math.Sin(angle * degreeToRadians) * hyp;
+        }
+
+        private static double CalculateAdjSide(double angle, double hyp)
+        {
+            return Math.Cos(angle * degreeToRadians) * hyp;
+        }
+
+        static Rect CalculateBounds(Point p1, Point p2, double thickness, double angleToCorner)
+        {
+            var pts = TranslatePointsAlongTangent(p1, p2, angleToCorner + 90, thickness / 2);
+
+            return new Rect(pts.p1, pts.p2);
+        }
+
+        static (Point p1, Point p2) TranslatePointsAlongTangent(Point p1, Point p2, double angle, double distance)
+        {
+            var xDiff = CalculateOppSide(angle, distance);
+            var yDiff = CalculateAdjSide(angle, distance);
+
+            var c1 = new Point(p1.X + xDiff, p1.Y - yDiff);
+            var c2 = new Point(p1.X - xDiff, p1.Y + yDiff);
+
+            var c3 = new Point(p2.X + xDiff, p2.Y - yDiff);
+            var c4 = new Point(p2.X - xDiff, p2.Y + yDiff);
+
+            var minX = Math.Min(c1.X, Math.Min(c2.X, Math.Min(c3.X, c4.X)));
+            var minY = Math.Min(c1.Y, Math.Min(c2.Y, Math.Min(c3.Y, c4.Y)));
+            var maxX = Math.Max(c1.X, Math.Max(c2.X, Math.Max(c3.X, c4.X)));
+            var maxY = Math.Max(c1.Y, Math.Max(c2.Y, Math.Max(c3.Y, c4.Y)));
+
+            return (new Point(minX, minY), new Point(maxX, maxY));
+        }
+
+        static Rect CalculateBounds(Point p1, Point p2, IPen p)
+        {
+            var angle = CalculateAngle(p1, p2);
+
+            var angleToCorner = 90 - angle;
+
+            if (p.LineCap != PenLineCap.Flat)
+            {
+                var pts = TranslatePointsAlongTangent(p1, p2, angleToCorner, p.Thickness / 2);
+
+                return CalculateBounds(pts.p1, pts.p2, p.Thickness, angleToCorner);
+            }
+            else
+            {
+                return CalculateBounds(p1, p2, p.Thickness, angleToCorner);
+            }
+        }
+
+
         /// <summary>
         /// Initializes a new instance of the <see cref="GeometryNode"/> class.
         /// </summary>
@@ -25,15 +93,19 @@ namespace Avalonia.Rendering.SceneGraph
             Point p1,
             Point p2,
             IDictionary<IVisual, Scene> childScenes = null)
-            : base(new Rect(p1, p2), transform, pen)
+            : base(CalculateBounds(p1, p2, pen), transform, pen)
         {
             Transform = transform;
             Pen = pen?.ToImmutable();
             P1 = p1;
             P2 = p2;
             ChildScenes = childScenes;
+
+            
         }
 
+        
+
         /// <summary>
         /// Gets the transform with which the node will be drawn.
         /// </summary>

From 0808e2810e2e6a4f51a09560990779f86bfa8879 Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Fri, 8 May 2020 21:05:14 -0300
Subject: [PATCH 06/32] move to static LineBoundsHelper class.

---
 samples/ControlCatalog/MainWindow.xaml.cs     | 75 ++-----------------
 .../Rendering/SceneGraph/LineBoundsHelper.cs  | 72 ++++++++++++++++++
 .../Rendering/SceneGraph/LineNode.cs          | 72 +-----------------
 3 files changed, 80 insertions(+), 139 deletions(-)
 create mode 100644 src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs

diff --git a/samples/ControlCatalog/MainWindow.xaml.cs b/samples/ControlCatalog/MainWindow.xaml.cs
index 954a76a4f9..ce7b85725e 100644
--- a/samples/ControlCatalog/MainWindow.xaml.cs
+++ b/samples/ControlCatalog/MainWindow.xaml.cs
@@ -3,6 +3,7 @@ using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Markup.Xaml;
 using Avalonia.Media;
+using Avalonia.Rendering.SceneGraph;
 using Avalonia.Threading;
 
 namespace ControlCatalog
@@ -20,95 +21,31 @@ namespace ControlCatalog
             t.Tick += (sender, e) =>
             {
                 angle += 1;
-               Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
+                Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
             };
 
             t.Start();
         }
 
-        const double degreeToRadians = Math.PI / 180.0;
 
-        private static double CalculateAngle(Point p1, Point p2)
-        {
-            var xDiff = p2.X - p1.X;
-            var yDiff = p2.Y - p1.Y;
-
-            return Math.Atan2(yDiff, xDiff) * 180.0 / Math.PI;
-        }
-
-        private static double CalculateOppSide(double angle, double hyp)
-        {
-            return Math.Sin(angle * degreeToRadians) * hyp;
-        }
-
-        private static double CalculateAdjSide(double angle, double hyp)
-        {   
-            return Math.Cos(angle * degreeToRadians) * hyp;
-        }
-
-        static Rect CalculateBounds(Point p1, Point p2, double thickness, double angleToCorner)
-        {
-            var pts = TranslatePointsAlongTangent(p1, p2, angleToCorner + 90, thickness / 2);
-
-            return new Rect(pts.p1, pts.p2);
-        }
-        
-        static (Point p1, Point p2) TranslatePointsAlongTangent(Point p1, Point p2, double angle, double distance)
-        {
-            var xDiff = CalculateOppSide(angle, distance);
-            var yDiff = CalculateAdjSide(angle, distance);            
-
-            var c1 = new Point(p1.X + xDiff, p1.Y - yDiff);
-            var c2 = new Point(p1.X - xDiff, p1.Y + yDiff);
-
-            var c3 = new Point(p2.X + xDiff, p2.Y - yDiff);
-            var c4 = new Point(p2.X - xDiff, p2.Y + yDiff);
-
-            var minX = Math.Min(c1.X, Math.Min(c2.X, Math.Min(c3.X, c4.X)));
-            var minY = Math.Min(c1.Y, Math.Min(c2.Y, Math.Min(c3.Y, c4.Y)));
-            var maxX = Math.Max(c1.X, Math.Max(c2.X, Math.Max(c3.X, c4.X)));
-            var maxY = Math.Max(c1.Y, Math.Max(c2.Y, Math.Max(c3.Y, c4.Y)));
-
-            return (new Point(minX, minY), new Point(maxX, maxY));            
-        }
-
-        static Rect CalculateBounds (Point p1, Point p2, Pen p)
-        {
-            var angle = CalculateAngle(p1, p2);
-
-            var angleToCorner = 90 - angle;
-
-            if (p.LineCap != PenLineCap.Flat)
-            {
-                var pts = TranslatePointsAlongTangent(p1, p2, angleToCorner, p.Thickness / 2);
-
-                return CalculateBounds(pts.p1, pts.p2, p.Thickness, angleToCorner);
-            }
-            else
-            {
-                return CalculateBounds(p1, p2, p.Thickness, angleToCorner);
-            }
-        }
-
-        
 
         public override void Render(DrawingContext drawingContext)
         {
             var lineLength = Math.Sqrt((100 * 100) + (100 * 100));
 
-            var diffX = CalculateAdjSide(angle, lineLength);
-            var diffY = CalculateOppSide(angle, lineLength);            
+            var diffX = LineBoundsHelper.CalculateAdjSide(angle, lineLength);
+            var diffY = LineBoundsHelper.CalculateOppSide(angle, lineLength);
 
 
             var p1 = new Point(400, 400);
             var p2 = new Point(p1.X + diffX, p1.Y + diffY);
 
-            var pen = new Pen(Brushes.Green, 20, lineCap: PenLineCap.Round);
+            var pen = new Pen(Brushes.Green, 20, lineCap: PenLineCap.Square);
             var boundPen = new Pen(Brushes.Black);
 
             drawingContext.DrawLine(pen, p1, p2);
 
-            drawingContext.DrawRectangle(boundPen, CalculateBounds(p1, p2, pen));
+            drawingContext.DrawRectangle(boundPen, LineBoundsHelper.CalculateBounds(p1, p2, pen));
 
             //Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
         }
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
new file mode 100644
index 0000000000..4111723ac3
--- /dev/null
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
@@ -0,0 +1,72 @@
+using System;
+using Avalonia.Media;
+
+namespace Avalonia.Rendering.SceneGraph
+{
+    public static class LineBoundsHelper
+    {
+        private const double degreeToRadians = Math.PI / 180.0;
+
+        private static double CalculateAngle(Point p1, Point p2)
+        {
+            var xDiff = p2.X - p1.X;
+            var yDiff = p2.Y - p1.Y;
+
+            return Math.Atan2(yDiff, xDiff) * 180.0 / Math.PI;
+        }
+
+        public static double CalculateOppSide(double angle, double hyp)
+        {
+            return Math.Sin(angle * degreeToRadians) * hyp;
+        }
+
+        public static double CalculateAdjSide(double angle, double hyp)
+        {
+            return Math.Cos(angle * degreeToRadians) * hyp;
+        }
+
+        private static (Point p1, Point p2) TranslatePointsAlongTangent(Point p1, Point p2, double angle, double distance)
+        {
+            var xDiff = CalculateAdjSide(angle, distance);
+            var yDiff = CalculateOppSide(angle, distance);
+
+            var c1 = new Point(p1.X + xDiff, p1.Y - yDiff);
+            var c2 = new Point(p1.X - xDiff, p1.Y + yDiff);
+
+            var c3 = new Point(p2.X + xDiff, p2.Y - yDiff);
+            var c4 = new Point(p2.X - xDiff, p2.Y + yDiff);
+
+            var minX = Math.Min(c1.X, Math.Min(c2.X, Math.Min(c3.X, c4.X)));
+            var minY = Math.Min(c1.Y, Math.Min(c2.Y, Math.Min(c3.Y, c4.Y)));
+            var maxX = Math.Max(c1.X, Math.Max(c2.X, Math.Max(c3.X, c4.X)));
+            var maxY = Math.Max(c1.Y, Math.Max(c2.Y, Math.Max(c3.Y, c4.Y)));
+
+            return (new Point(minX, minY), new Point(maxX, maxY));
+        }
+
+        private static Rect CalculateBounds(Point p1, Point p2, double thickness, double angleToCorner)
+        {
+            var pts = TranslatePointsAlongTangent(p1, p2, angleToCorner, thickness / 2);
+
+            return new Rect(pts.p1, pts.p2);
+        }
+
+        public static Rect CalculateBounds(Point p1, Point p2, IPen p)
+        {
+            var angle = CalculateAngle(p1, p2);
+
+            var angleToCorner = 90 - angle;
+
+            if (p.LineCap != PenLineCap.Flat)
+            {
+                var pts = TranslatePointsAlongTangent(p1, p2, angleToCorner - 90, p.Thickness / 2);
+
+                return CalculateBounds(pts.p1, pts.p2, p.Thickness, angleToCorner);
+            }
+            else
+            {
+                return CalculateBounds(p1, p2, p.Thickness, angleToCorner);
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs
index 1ff7aa8618..d2a9ece3a6 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs
@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using Avalonia.Media;
 using Avalonia.Media.Immutable;
 using Avalonia.Platform;
@@ -7,78 +6,11 @@ using Avalonia.VisualTree;
 
 namespace Avalonia.Rendering.SceneGraph
 {
-
     /// <summary>
     /// A node in the scene graph which represents a line draw.
     /// </summary>
     internal class LineNode : BrushDrawOperation
     {
-
-        const double degreeToRadians = Math.PI / 180.0;
-
-        private static double CalculateAngle(Point p1, Point p2)
-        {
-            var xDiff = p2.X - p1.X;
-            var yDiff = p2.Y - p1.Y;
-
-            return Math.Atan2(yDiff, xDiff) * 180.0 / Math.PI;
-        }
-
-        private static double CalculateOppSide(double angle, double hyp)
-        {
-            return Math.Sin(angle * degreeToRadians) * hyp;
-        }
-
-        private static double CalculateAdjSide(double angle, double hyp)
-        {
-            return Math.Cos(angle * degreeToRadians) * hyp;
-        }
-
-        static Rect CalculateBounds(Point p1, Point p2, double thickness, double angleToCorner)
-        {
-            var pts = TranslatePointsAlongTangent(p1, p2, angleToCorner + 90, thickness / 2);
-
-            return new Rect(pts.p1, pts.p2);
-        }
-
-        static (Point p1, Point p2) TranslatePointsAlongTangent(Point p1, Point p2, double angle, double distance)
-        {
-            var xDiff = CalculateOppSide(angle, distance);
-            var yDiff = CalculateAdjSide(angle, distance);
-
-            var c1 = new Point(p1.X + xDiff, p1.Y - yDiff);
-            var c2 = new Point(p1.X - xDiff, p1.Y + yDiff);
-
-            var c3 = new Point(p2.X + xDiff, p2.Y - yDiff);
-            var c4 = new Point(p2.X - xDiff, p2.Y + yDiff);
-
-            var minX = Math.Min(c1.X, Math.Min(c2.X, Math.Min(c3.X, c4.X)));
-            var minY = Math.Min(c1.Y, Math.Min(c2.Y, Math.Min(c3.Y, c4.Y)));
-            var maxX = Math.Max(c1.X, Math.Max(c2.X, Math.Max(c3.X, c4.X)));
-            var maxY = Math.Max(c1.Y, Math.Max(c2.Y, Math.Max(c3.Y, c4.Y)));
-
-            return (new Point(minX, minY), new Point(maxX, maxY));
-        }
-
-        static Rect CalculateBounds(Point p1, Point p2, IPen p)
-        {
-            var angle = CalculateAngle(p1, p2);
-
-            var angleToCorner = 90 - angle;
-
-            if (p.LineCap != PenLineCap.Flat)
-            {
-                var pts = TranslatePointsAlongTangent(p1, p2, angleToCorner, p.Thickness / 2);
-
-                return CalculateBounds(pts.p1, pts.p2, p.Thickness, angleToCorner);
-            }
-            else
-            {
-                return CalculateBounds(p1, p2, p.Thickness, angleToCorner);
-            }
-        }
-
-
         /// <summary>
         /// Initializes a new instance of the <see cref="GeometryNode"/> class.
         /// </summary>
@@ -93,7 +25,7 @@ namespace Avalonia.Rendering.SceneGraph
             Point p1,
             Point p2,
             IDictionary<IVisual, Scene> childScenes = null)
-            : base(CalculateBounds(p1, p2, pen), transform, pen)
+            : base(LineBoundsHelper.CalculateBounds(p1, p2, pen), transform, pen)
         {
             Transform = transform;
             Pen = pen?.ToImmutable();

From bf40f69a5ae71654dd1ed2a849390a5c8ccb212f Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Sat, 9 May 2020 12:07:27 -0300
Subject: [PATCH 07/32] inflate rectangle nodes to take into account the pen
 thickness.

---
 src/Avalonia.Visuals/Rendering/SceneGraph/RectangleNode.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/RectangleNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/RectangleNode.cs
index e48bad6433..56f43f0e89 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/RectangleNode.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/RectangleNode.cs
@@ -30,7 +30,7 @@ namespace Avalonia.Rendering.SceneGraph
             double radiusX,
             double radiusY,
             IDictionary<IVisual, Scene> childScenes = null)
-            : base(rect, transform, pen)
+            : base(rect.Inflate((pen?.Thickness ?? 0) / 2), transform, pen)
         {
             Transform = transform;
             Brush = brush?.ToImmutable();

From 9ee748f35e23e379e99fa1f7dfb3155494b76900 Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Sat, 9 May 2020 12:07:47 -0300
Subject: [PATCH 08/32] correct the terminology of the helper methods

---
 .../Rendering/SceneGraph/LineBoundsHelper.cs         | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
index 4111723ac3..9be7f45485 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
@@ -27,8 +27,8 @@ namespace Avalonia.Rendering.SceneGraph
 
         private static (Point p1, Point p2) TranslatePointsAlongTangent(Point p1, Point p2, double angle, double distance)
         {
-            var xDiff = CalculateAdjSide(angle, distance);
-            var yDiff = CalculateOppSide(angle, distance);
+            var xDiff = CalculateOppSide(angle, distance);
+            var yDiff = CalculateAdjSide(angle, distance);            
 
             var c1 = new Point(p1.X + xDiff, p1.Y - yDiff);
             var c2 = new Point(p1.X - xDiff, p1.Y + yDiff);
@@ -55,17 +55,17 @@ namespace Avalonia.Rendering.SceneGraph
         {
             var angle = CalculateAngle(p1, p2);
 
-            var angleToCorner = 90 - angle;
+            var angleToCorner = angle;
 
             if (p.LineCap != PenLineCap.Flat)
             {
-                var pts = TranslatePointsAlongTangent(p1, p2, angleToCorner - 90, p.Thickness / 2);
+                var pts = TranslatePointsAlongTangent(p1, p2, angle - 90, p.Thickness / 2);
 
-                return CalculateBounds(pts.p1, pts.p2, p.Thickness, angleToCorner);
+                return CalculateBounds(pts.p1, pts.p2, p.Thickness, angle);
             }
             else
             {
-                return CalculateBounds(p1, p2, p.Thickness, angleToCorner);
+                return CalculateBounds(p1, p2, p.Thickness, angle);
             }
         }
     }

From daa69f3ff4d3cd9e7c5f6913fd7f0212c401fc08 Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Sat, 9 May 2020 12:35:37 -0300
Subject: [PATCH 09/32] fix draw operation tests.

---
 .../Rendering/SceneGraph/DrawOperationTests.cs    | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
index 6a1f08a384..870f5155b5 100644
--- a/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
+++ b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
@@ -35,7 +35,7 @@ namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
             double expectedWidth,
             double expectedHeight)
         {
-            var target = new TestDrawOperation(
+            var target = new TestRectangleDrawOperation(
                 new Rect(x, y, width, height),
                 Matrix.CreateScale(scaleX, scaleY),
                 penThickness.HasValue ? new Pen(Brushes.Black, penThickness.Value) : null);
@@ -74,6 +74,19 @@ namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
             geometryNode.HitTest(new Point());
         }
 
+        private class TestRectangleDrawOperation : RectangleNode
+        {
+            public TestRectangleDrawOperation(Rect bounds, Matrix transform, Pen pen) 
+                : base(transform, pen.Brush, pen, bounds, 0, 0)
+            {
+
+            }
+
+            public override bool HitTest(Point p) => false;
+
+            public override void Render(IDrawingContextImpl context) { }
+        }
+
         private class TestDrawOperation : DrawOperation
         {
             public TestDrawOperation(Rect bounds, Matrix transform, Pen pen)

From 5eba04f06ce45093d3b582caee1489d7c82b6b88 Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Mon, 11 May 2020 15:33:52 -0300
Subject: [PATCH 10/32] do all calculations in radians.

---
 samples/ControlCatalog/MainWindow.xaml.cs        |  4 ++--
 .../Rendering/SceneGraph/LineBoundsHelper.cs     | 16 ++++++++--------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/samples/ControlCatalog/MainWindow.xaml.cs b/samples/ControlCatalog/MainWindow.xaml.cs
index ce7b85725e..9f10dd442a 100644
--- a/samples/ControlCatalog/MainWindow.xaml.cs
+++ b/samples/ControlCatalog/MainWindow.xaml.cs
@@ -12,7 +12,7 @@ namespace ControlCatalog
     {
         private Random _r = new Random();
 
-        private double angle = 45;
+        private double angle = Math.PI / 8;
         public TestControl()
         {
             DispatcherTimer t = new DispatcherTimer();
@@ -20,7 +20,7 @@ namespace ControlCatalog
 
             t.Tick += (sender, e) =>
             {
-                angle += 1;
+                angle += Math.PI / 360;
                 Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
             };
 
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
index 9be7f45485..f7ac072ced 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
@@ -12,17 +12,17 @@ namespace Avalonia.Rendering.SceneGraph
             var xDiff = p2.X - p1.X;
             var yDiff = p2.Y - p1.Y;
 
-            return Math.Atan2(yDiff, xDiff) * 180.0 / Math.PI;
+            return Math.Atan2(yDiff, xDiff);
         }
 
         public static double CalculateOppSide(double angle, double hyp)
         {
-            return Math.Sin(angle * degreeToRadians) * hyp;
+            return Math.Sin(angle) * hyp;
         }
 
         public static double CalculateAdjSide(double angle, double hyp)
         {
-            return Math.Cos(angle * degreeToRadians) * hyp;
+            return Math.Cos(angle) * hyp;
         }
 
         private static (Point p1, Point p2) TranslatePointsAlongTangent(Point p1, Point p2, double angle, double distance)
@@ -53,19 +53,19 @@ namespace Avalonia.Rendering.SceneGraph
 
         public static Rect CalculateBounds(Point p1, Point p2, IPen p)
         {
-            var angle = CalculateAngle(p1, p2);
+            var radians = CalculateAngle(p1, p2);
 
-            var angleToCorner = angle;
+            var angleToCorner = radians;
 
             if (p.LineCap != PenLineCap.Flat)
             {
-                var pts = TranslatePointsAlongTangent(p1, p2, angle - 90, p.Thickness / 2);
+                var pts = TranslatePointsAlongTangent(p1, p2, radians - Math.PI / 2, p.Thickness / 2);
 
-                return CalculateBounds(pts.p1, pts.p2, p.Thickness, angle);
+                return CalculateBounds(pts.p1, pts.p2, p.Thickness, radians);
             }
             else
             {
-                return CalculateBounds(p1, p2, p.Thickness, angle);
+                return CalculateBounds(p1, p2, p.Thickness, radians);
             }
         }
     }

From 287352f92ae4e902f24b16d353f25f1a51f9efca Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Mon, 11 May 2020 15:44:26 -0300
Subject: [PATCH 11/32] fix demo repro

---
 samples/ControlCatalog/MainWindow.xaml.cs          | 14 ++++++++++++--
 .../Rendering/SceneGraph/LineBoundsHelper.cs       |  4 ++--
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/samples/ControlCatalog/MainWindow.xaml.cs b/samples/ControlCatalog/MainWindow.xaml.cs
index 9f10dd442a..785624fba5 100644
--- a/samples/ControlCatalog/MainWindow.xaml.cs
+++ b/samples/ControlCatalog/MainWindow.xaml.cs
@@ -27,14 +27,24 @@ namespace ControlCatalog
             t.Start();
         }
 
+        public static double CalculateOppSide(double angle, double hyp)
+        {
+            return Math.Sin(angle) * hyp;
+        }
+
+        public static double CalculateAdjSide(double angle, double hyp)
+        {
+            return Math.Cos(angle) * hyp;
+        }
+
 
 
         public override void Render(DrawingContext drawingContext)
         {
             var lineLength = Math.Sqrt((100 * 100) + (100 * 100));
 
-            var diffX = LineBoundsHelper.CalculateAdjSide(angle, lineLength);
-            var diffY = LineBoundsHelper.CalculateOppSide(angle, lineLength);
+            var diffX = CalculateAdjSide(angle, lineLength);
+            var diffY = CalculateOppSide(angle, lineLength);
 
 
             var p1 = new Point(400, 400);
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
index f7ac072ced..7c9e1e1364 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
@@ -15,12 +15,12 @@ namespace Avalonia.Rendering.SceneGraph
             return Math.Atan2(yDiff, xDiff);
         }
 
-        public static double CalculateOppSide(double angle, double hyp)
+        private static double CalculateOppSide(double angle, double hyp)
         {
             return Math.Sin(angle) * hyp;
         }
 
-        public static double CalculateAdjSide(double angle, double hyp)
+        private static double CalculateAdjSide(double angle, double hyp)
         {
             return Math.Cos(angle) * hyp;
         }

From 4e0777145805f4e85b43f5fee17f0267f097c73a Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Mon, 11 May 2020 15:52:55 -0300
Subject: [PATCH 12/32] add to render demo

---
 .../Controls/LineBoundsDemoControl.cs         | 46 +++++++++++++++++++
 samples/RenderDemo/MainWindow.xaml            |  3 ++
 samples/RenderDemo/Pages/LineBoundsDemo.xaml  |  9 ++++
 .../RenderDemo/Pages/LineBoundsDemo.xaml.cs   | 19 ++++++++
 4 files changed, 77 insertions(+)
 create mode 100644 samples/RenderDemo/Controls/LineBoundsDemoControl.cs
 create mode 100644 samples/RenderDemo/Pages/LineBoundsDemo.xaml
 create mode 100644 samples/RenderDemo/Pages/LineBoundsDemo.xaml.cs

diff --git a/samples/RenderDemo/Controls/LineBoundsDemoControl.cs b/samples/RenderDemo/Controls/LineBoundsDemoControl.cs
new file mode 100644
index 0000000000..6030eae47b
--- /dev/null
+++ b/samples/RenderDemo/Controls/LineBoundsDemoControl.cs
@@ -0,0 +1,46 @@
+using System;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Media;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Threading;
+
+namespace RenderDemo.Controls
+{
+    public class LineBoundsDemoControl : Control
+    {
+        private double angle = Math.PI / 8;
+
+        public static double CalculateOppSide(double angle, double hyp)
+        {
+            return Math.Sin(angle) * hyp;
+        }
+
+        public static double CalculateAdjSide(double angle, double hyp)
+        {
+            return Math.Cos(angle) * hyp;
+        }
+
+        public override void Render(DrawingContext drawingContext)
+        {
+            var lineLength = Math.Sqrt((100 * 100) + (100 * 100));
+
+            var diffX = CalculateAdjSide(angle, lineLength);
+            var diffY = CalculateOppSide(angle, lineLength);
+
+
+            var p1 = new Point(200, 200);
+            var p2 = new Point(p1.X + diffX, p1.Y + diffY);
+
+            var pen = new Pen(Brushes.Green, 20, lineCap: PenLineCap.Square);
+            var boundPen = new Pen(Brushes.Black);
+
+            drawingContext.DrawLine(pen, p1, p2);
+
+            drawingContext.DrawRectangle(boundPen, LineBoundsHelper.CalculateBounds(p1, p2, pen));
+
+            angle += Math.PI / 360;
+            Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
+        }
+    }
+}
diff --git a/samples/RenderDemo/MainWindow.xaml b/samples/RenderDemo/MainWindow.xaml
index b17520a466..22925298fe 100644
--- a/samples/RenderDemo/MainWindow.xaml
+++ b/samples/RenderDemo/MainWindow.xaml
@@ -44,6 +44,9 @@
       <TabItem Header="GlyphRun">
         <pages:GlyphRunPage/>
       </TabItem>
+      <TabItem Header="LineBoundsDemo">
+        <pages:LineBoundsDemo />
+      </TabItem>
     </TabControl>
   </DockPanel>
 </Window>
diff --git a/samples/RenderDemo/Pages/LineBoundsDemo.xaml b/samples/RenderDemo/Pages/LineBoundsDemo.xaml
new file mode 100644
index 0000000000..55b2add070
--- /dev/null
+++ b/samples/RenderDemo/Pages/LineBoundsDemo.xaml
@@ -0,0 +1,9 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
+             xmlns:controls="clr-namespace:RenderDemo.Controls"
+             x:Class="RenderDemo.Pages.LineBoundsDemo">
+  <controls:LineBoundsDemoControl />
+</UserControl>
diff --git a/samples/RenderDemo/Pages/LineBoundsDemo.xaml.cs b/samples/RenderDemo/Pages/LineBoundsDemo.xaml.cs
new file mode 100644
index 0000000000..1b87cb1ef6
--- /dev/null
+++ b/samples/RenderDemo/Pages/LineBoundsDemo.xaml.cs
@@ -0,0 +1,19 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace RenderDemo.Pages
+{
+    public class LineBoundsDemo : UserControl
+    {
+        public LineBoundsDemo()
+        {
+            this.InitializeComponent();
+        }
+
+        private void InitializeComponent()
+        {
+            AvaloniaXamlLoader.Load(this);
+        }
+    }
+}

From 07261b61fe85bb8a8e937fe9e7f1e7c7f6e884e5 Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Mon, 11 May 2020 15:55:05 -0300
Subject: [PATCH 13/32] restore control catalog.

---
 samples/ControlCatalog/MainWindow.xaml    | 69 ++++++++++++++++--
 samples/ControlCatalog/MainWindow.xaml.cs | 87 +++++++++--------------
 2 files changed, 95 insertions(+), 61 deletions(-)

diff --git a/samples/ControlCatalog/MainWindow.xaml b/samples/ControlCatalog/MainWindow.xaml
index 117ddb8262..935db20757 100644
--- a/samples/ControlCatalog/MainWindow.xaml
+++ b/samples/ControlCatalog/MainWindow.xaml
@@ -9,11 +9,68 @@
         xmlns:v="clr-namespace:ControlCatalog.Views"
         x:Class="ControlCatalog.MainWindow" WindowState="{Binding WindowState, Mode=TwoWay}">
 
-  <DockPanel>
-    <StackPanel DockPanel.Dock="Top">
-      <Button Content="Test" />
-      <local:TestControl1 VerticalAlignment="Stretch" Height="20" />
-    </StackPanel>
-    <local:TestControl />
+  <NativeMenu.Menu>
+    <NativeMenu>
+      <NativeMenuItem Header="File">
+        <NativeMenuItem.Menu>
+          <NativeMenu>
+            <NativeMenuItem Icon="/Assets/test_icon.ico" Header="Open" Clicked="OnOpenClicked" Gesture="Ctrl+O"/>
+            <NativeMenuItemSeperator/>
+            <NativeMenuItem Icon="/Assets/github_icon.png" Header="Recent">
+              <NativeMenuItem.Menu>
+                <NativeMenu/>
+              </NativeMenuItem.Menu>
+            </NativeMenuItem>
+            <NativeMenuItemSeperator/>
+            <NativeMenuItem Header="{x:Static local:MainWindow.MenuQuitHeader}"
+                            Gesture="{x:Static local:MainWindow.MenuQuitGesture}"
+                            Clicked="OnCloseClicked" />
+          </NativeMenu>
+        </NativeMenuItem.Menu>
+      </NativeMenuItem>
+      <NativeMenuItem Header="Edit">
+        <NativeMenuItem.Menu>
+          <NativeMenu>
+            <NativeMenuItem Header="Copy"/>
+            <NativeMenuItem Header="Paste"/>
+          </NativeMenu>
+        </NativeMenuItem.Menu>
+      </NativeMenuItem>
+      <NativeMenuItem Header="Options">
+        <NativeMenuItem.Menu>
+          <NativeMenu>
+           <NativeMenuItem Header="Check Me (None)" 
+                            Command="{Binding ToggleMenuItemCheckedCommand}"
+                            ToggleType="None"
+                            IsChecked="{Binding IsMenuItemChecked}"  />
+            <NativeMenuItem Header="Check Me (CheckBox)" 
+                            Command="{Binding ToggleMenuItemCheckedCommand}"
+                            ToggleType="CheckBox"
+                            IsChecked="{Binding IsMenuItemChecked}"  />
+            <NativeMenuItem Header="Check Me (Radio)" 
+                            Command="{Binding ToggleMenuItemCheckedCommand}"
+                            ToggleType="Radio"
+                            IsChecked="{Binding IsMenuItemChecked}"  />
+          </NativeMenu>
+        </NativeMenuItem.Menu>
+      </NativeMenuItem>
+    </NativeMenu>
+  </NativeMenu.Menu>
+
+ <Window.DataTemplates>
+    <DataTemplate DataType="vm:NotificationViewModel">
+      <v:CustomNotificationView />
+    </DataTemplate>
+  </Window.DataTemplates>
+  <DockPanel LastChildFill="True">
+    <Menu Name="MainMenu" DockPanel.Dock="Top">
+      <MenuItem Header="File">
+        <MenuItem Header="Exit" Command="{Binding ExitCommand}" />
+      </MenuItem>
+      <MenuItem Header="Help">
+        <MenuItem Header="About" Command="{Binding AboutCommand}" />
+      </MenuItem>
+    </Menu>
+    <local:MainView />
   </DockPanel>
 </Window>
diff --git a/samples/ControlCatalog/MainWindow.xaml.cs b/samples/ControlCatalog/MainWindow.xaml.cs
index 785624fba5..d97325ef8d 100644
--- a/samples/ControlCatalog/MainWindow.xaml.cs
+++ b/samples/ControlCatalog/MainWindow.xaml.cs
@@ -1,84 +1,61 @@
 using System;
+using System.Runtime.InteropServices;
 using Avalonia;
 using Avalonia.Controls;
+using Avalonia.Controls.Notifications;
+using Avalonia.Input;
 using Avalonia.Markup.Xaml;
-using Avalonia.Media;
-using Avalonia.Rendering.SceneGraph;
-using Avalonia.Threading;
+using ControlCatalog.ViewModels;
 
 namespace ControlCatalog
 {
-    public class TestControl : Control
+    public class MainWindow : Window
     {
-        private Random _r = new Random();
+        private WindowNotificationManager _notificationArea;
+        private NativeMenu _recentMenu;
 
-        private double angle = Math.PI / 8;
-        public TestControl()
+        public MainWindow()
         {
-            DispatcherTimer t = new DispatcherTimer();
-            t.Interval = TimeSpan.FromSeconds(0.0125);
+            this.InitializeComponent();
+            this.AttachDevTools();
+            //Renderer.DrawFps = true;
+            //Renderer.DrawDirtyRects = Renderer.DrawFps = true;
 
-            t.Tick += (sender, e) =>
+            _notificationArea = new WindowNotificationManager(this)
             {
-                angle += Math.PI / 360;
-                Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
+                Position = NotificationPosition.TopRight,
+                MaxItems = 3
             };
 
-            t.Start();
-        }
-
-        public static double CalculateOppSide(double angle, double hyp)
-        {
-            return Math.Sin(angle) * hyp;
-        }
+            DataContext = new MainWindowViewModel(_notificationArea);
+            _recentMenu = ((NativeMenu.GetMenu(this).Items[0] as NativeMenuItem).Menu.Items[2] as NativeMenuItem).Menu;
 
-        public static double CalculateAdjSide(double angle, double hyp)
-        {
-            return Math.Cos(angle) * hyp;
+            var mainMenu = this.FindControl<Menu>("MainMenu");
+            mainMenu.AttachedToVisualTree += MenuAttached;
         }
 
+        public static string MenuQuitHeader => RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ? "Quit Avalonia" : "E_xit";
 
+        public static KeyGesture MenuQuitGesture => RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ?
+            new KeyGesture(Key.Q, KeyModifiers.Meta) :
+            new KeyGesture(Key.F4, KeyModifiers.Alt);
 
-        public override void Render(DrawingContext drawingContext)
+        public void MenuAttached(object sender, VisualTreeAttachmentEventArgs e)
         {
-            var lineLength = Math.Sqrt((100 * 100) + (100 * 100));
-
-            var diffX = CalculateAdjSide(angle, lineLength);
-            var diffY = CalculateOppSide(angle, lineLength);
-
-
-            var p1 = new Point(400, 400);
-            var p2 = new Point(p1.X + diffX, p1.Y + diffY);
-
-            var pen = new Pen(Brushes.Green, 20, lineCap: PenLineCap.Square);
-            var boundPen = new Pen(Brushes.Black);
-
-            drawingContext.DrawLine(pen, p1, p2);
-
-            drawingContext.DrawRectangle(boundPen, LineBoundsHelper.CalculateBounds(p1, p2, pen));
-
-            //Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
+            if (NativeMenu.GetIsNativeMenuExported(this) && sender is Menu mainMenu)
+            {
+                mainMenu.IsVisible = false;
+            }
         }
-    }
 
-    public class TestControl1 : Control
-    {
-        private Random _r = new Random();
-
-        public override void Render(DrawingContext drawingContext)
+        public void OnOpenClicked(object sender, EventArgs args)
         {
-            drawingContext.FillRectangle(Brushes.Red, Bounds);
+            _recentMenu.Items.Insert(0, new NativeMenuItem("Item " + (_recentMenu.Items.Count + 1)));
         }
-    }
 
-    /// <summary>
-    /// Interaction logic for MainWindow.xaml
-    /// </summary>
-    public partial class MainWindow : Window
-    {
-        public MainWindow()
+        public void OnCloseClicked(object sender, EventArgs args)
         {
-            InitializeComponent();
+            Close();
         }
 
         private void InitializeComponent()

From c49e2c66be3f4addc8f9eef16ffa70aa86cf6baa Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Mon, 11 May 2020 15:56:15 -0300
Subject: [PATCH 14/32] whitespace

---
 src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs
index d2a9ece3a6..daac1f2ead 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs
@@ -32,12 +32,8 @@ namespace Avalonia.Rendering.SceneGraph
             P1 = p1;
             P2 = p2;
             ChildScenes = childScenes;
-
-            
         }
 
-        
-
         /// <summary>
         /// Gets the transform with which the node will be drawn.
         /// </summary>

From 41bf3f69192c1a14a4f5c455c6e3e25903b6e726 Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Mon, 11 May 2020 15:58:16 -0300
Subject: [PATCH 15/32] remove unused code.

---
 .../Rendering/SceneGraph/LineBoundsHelper.cs                | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
index 7c9e1e1364..4b5527ce6f 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
@@ -5,8 +5,6 @@ namespace Avalonia.Rendering.SceneGraph
 {
     public static class LineBoundsHelper
     {
-        private const double degreeToRadians = Math.PI / 180.0;
-
         private static double CalculateAngle(Point p1, Point p2)
         {
             var xDiff = p2.X - p1.X;
@@ -28,7 +26,7 @@ namespace Avalonia.Rendering.SceneGraph
         private static (Point p1, Point p2) TranslatePointsAlongTangent(Point p1, Point p2, double angle, double distance)
         {
             var xDiff = CalculateOppSide(angle, distance);
-            var yDiff = CalculateAdjSide(angle, distance);            
+            var yDiff = CalculateAdjSide(angle, distance);
 
             var c1 = new Point(p1.X + xDiff, p1.Y - yDiff);
             var c2 = new Point(p1.X - xDiff, p1.Y + yDiff);
@@ -55,8 +53,6 @@ namespace Avalonia.Rendering.SceneGraph
         {
             var radians = CalculateAngle(p1, p2);
 
-            var angleToCorner = radians;
-
             if (p.LineCap != PenLineCap.Flat)
             {
                 var pts = TranslatePointsAlongTangent(p1, p2, radians - Math.PI / 2, p.Thickness / 2);

From f270a1eafd72f73ef37f9f9a8eec725945772538 Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Mon, 11 May 2020 16:55:34 -0300
Subject: [PATCH 16/32] remove pen argument from DrawOperation and
 BrushDrawOperation

---
 .../Rendering/SceneGraph/BrushDrawOperation.cs                | 4 ++--
 .../Rendering/SceneGraph/CustomDrawOperation.cs               | 2 +-
 src/Avalonia.Visuals/Rendering/SceneGraph/DrawOperation.cs    | 2 +-
 src/Avalonia.Visuals/Rendering/SceneGraph/GeometryNode.cs     | 2 +-
 src/Avalonia.Visuals/Rendering/SceneGraph/GlyphRunNode.cs     | 2 +-
 src/Avalonia.Visuals/Rendering/SceneGraph/ImageNode.cs        | 2 +-
 src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs         | 2 +-
 src/Avalonia.Visuals/Rendering/SceneGraph/OpacityMaskNode.cs  | 4 ++--
 src/Avalonia.Visuals/Rendering/SceneGraph/RectangleNode.cs    | 2 +-
 src/Avalonia.Visuals/Rendering/SceneGraph/TextNode.cs         | 2 +-
 .../Rendering/SceneGraph/DrawOperationTests.cs                | 4 ++--
 11 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/BrushDrawOperation.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/BrushDrawOperation.cs
index 315076570e..c559f05d70 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/BrushDrawOperation.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/BrushDrawOperation.cs
@@ -9,8 +9,8 @@ namespace Avalonia.Rendering.SceneGraph
     /// </summary>
     internal abstract class BrushDrawOperation : DrawOperation
     {
-        public BrushDrawOperation(Rect bounds, Matrix transform, IPen pen)
-            : base(bounds, transform, pen)
+        public BrushDrawOperation(Rect bounds, Matrix transform)
+            : base(bounds, transform)
         {
         }
 
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/CustomDrawOperation.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/CustomDrawOperation.cs
index 68e2237430..15e5660671 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/CustomDrawOperation.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/CustomDrawOperation.cs
@@ -9,7 +9,7 @@ namespace Avalonia.Rendering.SceneGraph
         public Matrix Transform { get; }
         public ICustomDrawOperation Custom { get; }
         public CustomDrawOperation(ICustomDrawOperation custom, Matrix transform) 
-            : base(custom.Bounds, transform, null)
+            : base(custom.Bounds, transform)
         {
             Transform = transform;
             Custom = custom;
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/DrawOperation.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/DrawOperation.cs
index 983a785577..0b04b97ff2 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/DrawOperation.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/DrawOperation.cs
@@ -9,7 +9,7 @@ namespace Avalonia.Rendering.SceneGraph
     /// </summary>
     internal abstract class DrawOperation : IDrawOperation
     {
-        public DrawOperation(Rect bounds, Matrix transform, IPen pen)
+        public DrawOperation(Rect bounds, Matrix transform)
         {
             bounds = bounds.TransformToAABB(transform);
             Bounds = new Rect(
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/GeometryNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/GeometryNode.cs
index cb7498f7b7..8a19679c77 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/GeometryNode.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/GeometryNode.cs
@@ -24,7 +24,7 @@ namespace Avalonia.Rendering.SceneGraph
             IPen pen,
             IGeometryImpl geometry,
             IDictionary<IVisual, Scene> childScenes = null)
-            : base(geometry.GetRenderBounds(pen), transform, null)
+            : base(geometry.GetRenderBounds(pen), transform)
         {
             Transform = transform;
             Brush = brush?.ToImmutable();
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/GlyphRunNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/GlyphRunNode.cs
index 9f314a5727..eaf4effdbe 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/GlyphRunNode.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/GlyphRunNode.cs
@@ -25,7 +25,7 @@ namespace Avalonia.Rendering.SceneGraph
             GlyphRun glyphRun,
             Point baselineOrigin,
             IDictionary<IVisual, Scene> childScenes = null)
-            : base(glyphRun.Bounds, transform, null)
+            : base(glyphRun.Bounds, transform)
         {
             Transform = transform;
             Foreground = foreground?.ToImmutable();
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/ImageNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/ImageNode.cs
index d1bc261c7a..c9052c6ef2 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/ImageNode.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/ImageNode.cs
@@ -19,7 +19,7 @@ namespace Avalonia.Rendering.SceneGraph
         /// <param name="destRect">The destination rect.</param>
         /// <param name="bitmapInterpolationMode">The bitmap interpolation mode.</param>
         public ImageNode(Matrix transform, IRef<IBitmapImpl> source, double opacity, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode)
-            : base(destRect, transform, null)
+            : base(destRect, transform)
         {
             Transform = transform;
             Source = source.Clone();
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs
index daac1f2ead..54a9ff733d 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/LineNode.cs
@@ -25,7 +25,7 @@ namespace Avalonia.Rendering.SceneGraph
             Point p1,
             Point p2,
             IDictionary<IVisual, Scene> childScenes = null)
-            : base(LineBoundsHelper.CalculateBounds(p1, p2, pen), transform, pen)
+            : base(LineBoundsHelper.CalculateBounds(p1, p2, pen), transform)
         {
             Transform = transform;
             Pen = pen?.ToImmutable();
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/OpacityMaskNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/OpacityMaskNode.cs
index d6dbc1a8cb..b8e7b150ac 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/OpacityMaskNode.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/OpacityMaskNode.cs
@@ -18,7 +18,7 @@ namespace Avalonia.Rendering.SceneGraph
         /// <param name="bounds">The bounds of the mask.</param>
         /// <param name="childScenes">Child scenes for drawing visual brushes.</param>
         public OpacityMaskNode(IBrush mask, Rect bounds, IDictionary<IVisual, Scene> childScenes = null)
-            : base(Rect.Empty, Matrix.Identity, null)
+            : base(Rect.Empty, Matrix.Identity)
         {
             Mask = mask?.ToImmutable();
             MaskBounds = bounds;
@@ -30,7 +30,7 @@ namespace Avalonia.Rendering.SceneGraph
         /// opacity mask pop.
         /// </summary>
         public OpacityMaskNode()
-            : base(Rect.Empty, Matrix.Identity, null)
+            : base(Rect.Empty, Matrix.Identity)
         {
         }
 
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/RectangleNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/RectangleNode.cs
index 0d3ab840b2..5059a6d042 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/RectangleNode.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/RectangleNode.cs
@@ -28,7 +28,7 @@ namespace Avalonia.Rendering.SceneGraph
             RoundedRect rect,
             BoxShadows boxShadows,
             IDictionary<IVisual, Scene> childScenes = null)
-            : base(boxShadows.TransformBounds(rect.Rect).Inflate((pen?.Thickness ?? 0) / 2), transform, pen)
+            : base(boxShadows.TransformBounds(rect.Rect).Inflate((pen?.Thickness ?? 0) / 2), transform)
         {
             Transform = transform;
             Brush = brush?.ToImmutable();
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/TextNode.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/TextNode.cs
index 336207dedf..4b6c331023 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/TextNode.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/TextNode.cs
@@ -24,7 +24,7 @@ namespace Avalonia.Rendering.SceneGraph
             Point origin,
             IFormattedTextImpl text,
             IDictionary<IVisual, Scene> childScenes = null)
-            : base(text.Bounds.Translate(origin), transform, null)
+            : base(text.Bounds.Translate(origin), transform)
         {
             Transform = transform;
             Foreground = foreground?.ToImmutable();
diff --git a/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
index f50c71b079..0cdc8827ad 100644
--- a/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
+++ b/tests/Avalonia.Visuals.UnitTests/Rendering/SceneGraph/DrawOperationTests.cs
@@ -77,7 +77,7 @@ namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
         private class TestRectangleDrawOperation : RectangleNode
         {
             public TestRectangleDrawOperation(Rect bounds, Matrix transform, Pen pen) 
-                : base(transform, pen.Brush, pen, bounds, 0, 0)
+                : base(transform, pen.Brush, pen, bounds, new BoxShadows())
             {
 
             }
@@ -90,7 +90,7 @@ namespace Avalonia.Visuals.UnitTests.Rendering.SceneGraph
         private class TestDrawOperation : DrawOperation
         {
             public TestDrawOperation(Rect bounds, Matrix transform, Pen pen)
-                :base(bounds, transform, pen)
+                :base(bounds, transform)
             {
             }
 

From cf155200a7493776c97cfc921c684da84ea79fb9 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Tue, 12 May 2020 20:31:59 +0200
Subject: [PATCH 17/32] Don't inflate geometry by stroke width twice.

We're already passing the stroke width to `UpdatePathCache` which should include it in its calculations. Here we were applying the stroke width twice.
---
 src/Skia/Avalonia.Skia/GeometryImpl.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Skia/Avalonia.Skia/GeometryImpl.cs b/src/Skia/Avalonia.Skia/GeometryImpl.cs
index 1d78609f5d..879b18742e 100644
--- a/src/Skia/Avalonia.Skia/GeometryImpl.cs
+++ b/src/Skia/Avalonia.Skia/GeometryImpl.cs
@@ -95,7 +95,7 @@ namespace Avalonia.Skia
                 UpdatePathCache(strokeWidth);
             }
             
-            return _pathCache.CachedGeometryRenderBounds.Inflate(strokeWidth / 2.0);
+            return _pathCache.CachedGeometryRenderBounds;
         }
         
         /// <inheritdoc />

From fc5c814cfa2580c4d24b06986a8def8555ee2f66 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Tue, 12 May 2020 22:57:19 +0200
Subject: [PATCH 18/32] Correctly snap dirty rects to device pixels.

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

diff --git a/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs b/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs
index 0e6dda1710..59dd369956 100644
--- a/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs
+++ b/src/Avalonia.Visuals/Rendering/DeferredRenderer.cs
@@ -443,11 +443,12 @@ namespace Avalonia.Rendering
         private static Rect SnapToDevicePixels(Rect rect, double scale)
         {
             return new Rect(
-                Math.Floor(rect.X * scale) / scale,
-                Math.Floor(rect.Y * scale) / scale,
-                Math.Ceiling(rect.Width * scale) / scale,
-                Math.Ceiling(rect.Height * scale) / scale);
-                
+                new Point(
+                    Math.Floor(rect.X * scale) / scale,
+                    Math.Floor(rect.Y * scale) / scale),
+                new Point(
+                    Math.Ceiling(rect.Right * scale) / scale,
+                    Math.Ceiling(rect.Bottom * scale) / scale));
         }
 
         private void RenderOverlay(Scene scene, ref IDrawingContextImpl parentContent)

From 313f334d1c165f1e36b2101df6d702ff38036620 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Tue, 12 May 2020 23:28:28 +0200
Subject: [PATCH 19/32] Added failing PixelRect snapping tests.

---
 .../Media/PixelRectTests.cs                   | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 tests/Avalonia.Visuals.UnitTests/Media/PixelRectTests.cs

diff --git a/tests/Avalonia.Visuals.UnitTests/Media/PixelRectTests.cs b/tests/Avalonia.Visuals.UnitTests/Media/PixelRectTests.cs
new file mode 100644
index 0000000000..c6da9b77e9
--- /dev/null
+++ b/tests/Avalonia.Visuals.UnitTests/Media/PixelRectTests.cs
@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+
+namespace Avalonia.Visuals.UnitTests.Media
+{
+    public class PixelRectTests
+    {
+        [Fact]
+        public void FromRect_Snaps_To_Device_Pixels()
+        {
+            var rect = new Rect(189, 189, 26, 164);
+            var result = PixelRect.FromRect(rect, 1.5);
+
+            Assert.Equal(new PixelRect(283, 283, 40, 247), result);
+        }
+
+        [Fact]
+        public void FromRect_Vector_Snaps_To_Device_Pixels()
+        {
+            var rect = new Rect(189, 189, 26, 164);
+            var result = PixelRect.FromRect(rect, new Vector(1.5, 1.5));
+
+            Assert.Equal(new PixelRect(283, 283, 40, 247), result);
+        }
+
+        [Fact]
+        public void FromRectWithDpi_Snaps_To_Device_Pixels()
+        {
+            var rect = new Rect(189, 189, 26, 164);
+            var result = PixelRect.FromRectWithDpi(rect, 144);
+
+            Assert.Equal(new PixelRect(283, 283, 40, 247), result);
+        }
+
+        [Fact]
+        public void FromRectWithDpi_Vector_Snaps_To_Device_Pixels()
+        {
+            var rect = new Rect(189, 189, 26, 164);
+            var result = PixelRect.FromRectWithDpi(rect, new Vector(144, 144));
+
+            Assert.Equal(new PixelRect(283, 283, 40, 247), result);
+        }
+    }
+}

From 07fd1731e74ee6a45f8af41b8c2e02e7968e45c4 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Tue, 12 May 2020 23:28:46 +0200
Subject: [PATCH 20/32] Fix PixelRect snapping.

---
 src/Avalonia.Visuals/Media/PixelRect.cs | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/Avalonia.Visuals/Media/PixelRect.cs b/src/Avalonia.Visuals/Media/PixelRect.cs
index c062112ace..32a728475f 100644
--- a/src/Avalonia.Visuals/Media/PixelRect.cs
+++ b/src/Avalonia.Visuals/Media/PixelRect.cs
@@ -377,7 +377,7 @@ namespace Avalonia
         /// <returns>The device-independent rect.</returns>
         public static PixelRect FromRect(Rect rect, double scale) => new PixelRect(
             PixelPoint.FromPoint(rect.Position, scale),
-            PixelSize.FromSize(rect.Size, scale));
+            FromPointCeiling(rect.BottomRight, new Vector(scale, scale)));
 
         /// <summary>
         /// Converts a <see cref="Rect"/> to device pixels using the specified scaling factor.
@@ -387,7 +387,7 @@ namespace Avalonia
         /// <returns>The device-independent point.</returns>
         public static PixelRect FromRect(Rect rect, Vector scale) => new PixelRect(
             PixelPoint.FromPoint(rect.Position, scale),
-            PixelSize.FromSize(rect.Size, scale));
+            FromPointCeiling(rect.BottomRight, scale));
 
         /// <summary>
         /// Converts a <see cref="Rect"/> to device pixels using the specified dots per inch (DPI).
@@ -397,7 +397,7 @@ namespace Avalonia
         /// <returns>The device-independent point.</returns>
         public static PixelRect FromRectWithDpi(Rect rect, double dpi) => new PixelRect(
             PixelPoint.FromPointWithDpi(rect.Position, dpi),
-            PixelSize.FromSizeWithDpi(rect.Size, dpi));
+            FromPointCeiling(rect.BottomRight, new Vector(dpi / 96, dpi / 96)));
 
         /// <summary>
         /// Converts a <see cref="Rect"/> to device pixels using the specified dots per inch (DPI).
@@ -407,7 +407,7 @@ namespace Avalonia
         /// <returns>The device-independent point.</returns>
         public static PixelRect FromRectWithDpi(Rect rect, Vector dpi) => new PixelRect(
             PixelPoint.FromPointWithDpi(rect.Position, dpi),
-            PixelSize.FromSizeWithDpi(rect.Size, dpi));
+            FromPointCeiling(rect.BottomRight, dpi / 96));
 
         /// <summary>
         /// Returns the string representation of the rectangle.
@@ -441,5 +441,12 @@ namespace Avalonia
                 );
             }
         }
+
+        private static PixelPoint FromPointCeiling(Point point, Vector scale)
+        {
+            return new PixelPoint(
+                (int)Math.Ceiling(point.X * scale.X),
+                (int)Math.Ceiling(point.Y * scale.Y));
+        }
     }
 }

From 957eef7dbaedef4f4a47f644eafd376de279c9fc Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Wed, 13 May 2020 09:59:15 -0300
Subject: [PATCH 21/32] share linebouds helper with render demo. remove hacky
 test code.

---
 .../Controls/LineBoundsDemoControl.cs         | 27 ++++++++++++-------
 samples/RenderDemo/RenderDemo.csproj          |  3 +++
 .../Rendering/SceneGraph/LineBoundsHelper.cs  |  6 ++---
 3 files changed, 23 insertions(+), 13 deletions(-)

diff --git a/samples/RenderDemo/Controls/LineBoundsDemoControl.cs b/samples/RenderDemo/Controls/LineBoundsDemoControl.cs
index 6030eae47b..0e0b3d6142 100644
--- a/samples/RenderDemo/Controls/LineBoundsDemoControl.cs
+++ b/samples/RenderDemo/Controls/LineBoundsDemoControl.cs
@@ -9,24 +9,34 @@ namespace RenderDemo.Controls
 {
     public class LineBoundsDemoControl : Control
     {
-        private double angle = Math.PI / 8;
+        static LineBoundsDemoControl()
+        {
+            AffectsRender<LineBoundsDemoControl>(AngleProperty);
+        }
 
-        public static double CalculateOppSide(double angle, double hyp)
+        public LineBoundsDemoControl()
         {
-            return Math.Sin(angle) * hyp;
+            var timer = new DispatcherTimer();
+            timer.Interval = TimeSpan.FromSeconds(1 / 60);
+            timer.Tick += (sender, e) => Angle += Math.PI / 360;
+            timer.Start();
         }
 
-        public static double CalculateAdjSide(double angle, double hyp)
+        public static readonly StyledProperty<double> AngleProperty =
+            AvaloniaProperty.Register<LineBoundsDemoControl, double>(nameof(Angle));        
+
+        public double Angle
         {
-            return Math.Cos(angle) * hyp;
+            get => GetValue(AngleProperty);
+            set => SetValue(AngleProperty, value);
         }
 
         public override void Render(DrawingContext drawingContext)
         {
             var lineLength = Math.Sqrt((100 * 100) + (100 * 100));
 
-            var diffX = CalculateAdjSide(angle, lineLength);
-            var diffY = CalculateOppSide(angle, lineLength);
+            var diffX = LineBoundsHelper.CalculateAdjSide(Angle, lineLength);
+            var diffY = LineBoundsHelper.CalculateOppSide(Angle, lineLength);
 
 
             var p1 = new Point(200, 200);
@@ -38,9 +48,6 @@ namespace RenderDemo.Controls
             drawingContext.DrawLine(pen, p1, p2);
 
             drawingContext.DrawRectangle(boundPen, LineBoundsHelper.CalculateBounds(p1, p2, pen));
-
-            angle += Math.PI / 360;
-            Dispatcher.UIThread.Post(InvalidateVisual, DispatcherPriority.Background);
         }
     }
 }
diff --git a/samples/RenderDemo/RenderDemo.csproj b/samples/RenderDemo/RenderDemo.csproj
index ce33f42143..0d7d62e177 100644
--- a/samples/RenderDemo/RenderDemo.csproj
+++ b/samples/RenderDemo/RenderDemo.csproj
@@ -3,6 +3,9 @@
     <OutputType>Exe</OutputType>
     <TargetFramework>netcoreapp3.1</TargetFramework>
   </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="..\..\src\Avalonia.Visuals\Rendering\SceneGraph\LineBoundsHelper.cs" Link="LineBoundsHelper.cs" />
+  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\src\Avalonia.Diagnostics\Avalonia.Diagnostics.csproj" />
     <ProjectReference Include="..\..\src\Linux\Avalonia.LinuxFramebuffer\Avalonia.LinuxFramebuffer.csproj" />
diff --git a/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs b/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
index 4b5527ce6f..56d218e398 100644
--- a/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
+++ b/src/Avalonia.Visuals/Rendering/SceneGraph/LineBoundsHelper.cs
@@ -3,7 +3,7 @@ using Avalonia.Media;
 
 namespace Avalonia.Rendering.SceneGraph
 {
-    public static class LineBoundsHelper
+    internal static class LineBoundsHelper
     {
         private static double CalculateAngle(Point p1, Point p2)
         {
@@ -13,12 +13,12 @@ namespace Avalonia.Rendering.SceneGraph
             return Math.Atan2(yDiff, xDiff);
         }
 
-        private static double CalculateOppSide(double angle, double hyp)
+        internal static double CalculateOppSide(double angle, double hyp)
         {
             return Math.Sin(angle) * hyp;
         }
 
-        private static double CalculateAdjSide(double angle, double hyp)
+        internal static double CalculateAdjSide(double angle, double hyp)
         {
             return Math.Cos(angle) * hyp;
         }

From b3b7a57397e0a6bd155fb6a2f035845972a6d21b Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Wed, 13 May 2020 10:09:10 -0300
Subject: [PATCH 22/32] use consistent naming in renderdemo

---
 samples/RenderDemo/MainWindow.xaml                            | 4 ++--
 .../Pages/{LineBoundsDemo.xaml => LineBoundsPage.xaml}        | 2 +-
 .../Pages/{LineBoundsDemo.xaml.cs => LineBoundsPage.xaml.cs}  | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)
 rename samples/RenderDemo/Pages/{LineBoundsDemo.xaml => LineBoundsPage.xaml} (89%)
 rename samples/RenderDemo/Pages/{LineBoundsDemo.xaml.cs => LineBoundsPage.xaml.cs} (78%)

diff --git a/samples/RenderDemo/MainWindow.xaml b/samples/RenderDemo/MainWindow.xaml
index 22925298fe..c098ef411e 100644
--- a/samples/RenderDemo/MainWindow.xaml
+++ b/samples/RenderDemo/MainWindow.xaml
@@ -44,8 +44,8 @@
       <TabItem Header="GlyphRun">
         <pages:GlyphRunPage/>
       </TabItem>
-      <TabItem Header="LineBoundsDemo">
-        <pages:LineBoundsDemo />
+      <TabItem Header="LineBounds">
+        <pages:LineBoundsPage />
       </TabItem>
     </TabControl>
   </DockPanel>
diff --git a/samples/RenderDemo/Pages/LineBoundsDemo.xaml b/samples/RenderDemo/Pages/LineBoundsPage.xaml
similarity index 89%
rename from samples/RenderDemo/Pages/LineBoundsDemo.xaml
rename to samples/RenderDemo/Pages/LineBoundsPage.xaml
index 55b2add070..07d658630a 100644
--- a/samples/RenderDemo/Pages/LineBoundsDemo.xaml
+++ b/samples/RenderDemo/Pages/LineBoundsPage.xaml
@@ -4,6 +4,6 @@
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
              xmlns:controls="clr-namespace:RenderDemo.Controls"
-             x:Class="RenderDemo.Pages.LineBoundsDemo">
+             x:Class="RenderDemo.Pages.LineBoundsPage">
   <controls:LineBoundsDemoControl />
 </UserControl>
diff --git a/samples/RenderDemo/Pages/LineBoundsDemo.xaml.cs b/samples/RenderDemo/Pages/LineBoundsPage.xaml.cs
similarity index 78%
rename from samples/RenderDemo/Pages/LineBoundsDemo.xaml.cs
rename to samples/RenderDemo/Pages/LineBoundsPage.xaml.cs
index 1b87cb1ef6..28ddedd4bc 100644
--- a/samples/RenderDemo/Pages/LineBoundsDemo.xaml.cs
+++ b/samples/RenderDemo/Pages/LineBoundsPage.xaml.cs
@@ -4,9 +4,9 @@ using Avalonia.Markup.Xaml;
 
 namespace RenderDemo.Pages
 {
-    public class LineBoundsDemo : UserControl
+    public class LineBoundsPage : UserControl
     {
-        public LineBoundsDemo()
+        public LineBoundsPage()
         {
             this.InitializeComponent();
         }

From 2be01a6f0105a09f96b38804d108eb835ba828b8 Mon Sep 17 00:00:00 2001
From: sdoroff <sdoroff@gmail.com>
Date: Wed, 13 May 2020 10:21:50 -0400
Subject: [PATCH 23/32] Ignore initial value of AutoComplete TextBox

---
 src/Avalonia.Controls/AutoCompleteBox.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/Avalonia.Controls/AutoCompleteBox.cs b/src/Avalonia.Controls/AutoCompleteBox.cs
index 3e4f47ec8a..b38cc56a17 100644
--- a/src/Avalonia.Controls/AutoCompleteBox.cs
+++ b/src/Avalonia.Controls/AutoCompleteBox.cs
@@ -10,6 +10,7 @@ using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Linq;
+using System.Reactive.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Avalonia.Collections;
@@ -1100,6 +1101,7 @@ namespace Avalonia.Controls
                 {
                     _textBoxSubscriptions =
                         _textBox.GetObservable(TextBox.TextProperty)
+                                .Skip(1)
                                 .Subscribe(_ => OnTextBoxTextChanged());
 
                     if (Text != null)

From 8e29811c91ff6f4e6ecedd1bc817041d3e1070f8 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Wed, 13 May 2020 23:01:41 +0200
Subject: [PATCH 24/32] Added failing test for #3934.

---
 .../ListBoxTests.cs                           | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/tests/Avalonia.Controls.UnitTests/ListBoxTests.cs b/tests/Avalonia.Controls.UnitTests/ListBoxTests.cs
index d43385142d..a7679ba388 100644
--- a/tests/Avalonia.Controls.UnitTests/ListBoxTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ListBoxTests.cs
@@ -367,6 +367,46 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void Clicking_Item_Should_Raise_BringIntoView_For_Correct_Control()
+        {
+            // Issue #3934
+            var items = Enumerable.Range(0, 10).Select(x => $"Item {x}").ToArray();
+            var target = new ListBox
+            {
+                Template = ListBoxTemplate(),
+                Items = items,
+                ItemTemplate = new FuncDataTemplate<string>((x, _) => new TextBlock { Height = 10 }),
+                SelectionMode = SelectionMode.AlwaysSelected,
+                VirtualizationMode = ItemVirtualizationMode.None,
+            };
+
+            Prepare(target);
+
+            // First an item that is not index 0 must be selected.
+            _mouse.Click(target.Presenter.Panel.Children[1]);
+            Assert.Equal(new IndexPath(1), target.Selection.AnchorIndex);
+
+            // We're going to be clicking on item 9.
+            var item = (ListBoxItem)target.Presenter.Panel.Children[9];
+            var raised = 0;
+
+            // Make sure a RequestBringIntoView event is raised for item 9. It won't be handled
+            // by the ScrollContentPresenter as the item is already visible, so we don't need
+            // handledEventsToo: true. Issue #3934 failed here because item 0 was being scrolled
+            // into view due to SelectionMode.AlwaysSelected.
+            target.AddHandler(Control.RequestBringIntoViewEvent, (s, e) =>
+            {
+                Assert.Same(item, e.TargetObject);
+                ++raised;
+            });
+
+            // Click item 9.
+            _mouse.Click(item);
+
+            Assert.Equal(1, raised);
+        }
+
         private FuncControlTemplate ListBoxTemplate()
         {
             return new FuncControlTemplate<ListBox>((parent, scope) =>

From 7f87c2e74ab0c3f2b00cdce441264e3520cfeb23 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Wed, 13 May 2020 23:27:11 +0200
Subject: [PATCH 25/32] Don't raise SelectionModel.PropertyChanged during
 update.

---
 src/Avalonia.Controls/SelectionModel.cs       | 35 +++++++-----
 .../SelectionModelTests.cs                    | 54 +++++++++++++++++++
 2 files changed, 76 insertions(+), 13 deletions(-)

diff --git a/src/Avalonia.Controls/SelectionModel.cs b/src/Avalonia.Controls/SelectionModel.cs
index dd4934f9e5..93699583e6 100644
--- a/src/Avalonia.Controls/SelectionModel.cs
+++ b/src/Avalonia.Controls/SelectionModel.cs
@@ -20,6 +20,7 @@ namespace Avalonia.Controls
         private bool _singleSelect;
         private bool _autoSelect;
         private int _operationCount;
+        private IndexPath _oldAnchorIndex;
         private IReadOnlyList<IndexPath>? _selectedIndicesCached;
         private IReadOnlyList<object?>? _selectedItemsCached;
         private SelectionModelChildrenRequestedEventArgs? _childrenRequestedEventArgs;
@@ -142,6 +143,8 @@ namespace Avalonia.Controls
             }
             set
             {
+                var oldValue = AnchorIndex;
+
                 if (value != null)
                 {
                     SelectionTreeHelper.TraverseIndexPath(
@@ -155,7 +158,10 @@ namespace Avalonia.Controls
                     _rootNode.AnchorIndex = -1;
                 }
 
-                RaisePropertyChanged("AnchorIndex");
+                if (_operationCount == 0 && oldValue != AnchorIndex)
+                {
+                    RaisePropertyChanged("AnchorIndex");
+                }
             }
         }
 
@@ -633,19 +639,18 @@ namespace Avalonia.Controls
             _selectedIndicesCached = null;
             _selectedItemsCached = null;
 
-            // Raise SelectionChanged event
             if (e != null)
             {
                 SelectionChanged?.Invoke(this, e);
-            }
 
-            RaisePropertyChanged(nameof(SelectedIndex));
-            RaisePropertyChanged(nameof(SelectedIndices));
+                RaisePropertyChanged(nameof(SelectedIndex));
+                RaisePropertyChanged(nameof(SelectedIndices));
 
-            if (_rootNode.Source != null)
-            {
-                RaisePropertyChanged(nameof(SelectedItem));
-                RaisePropertyChanged(nameof(SelectedItems));
+                if (_rootNode.Source != null)
+                {
+                    RaisePropertyChanged(nameof(SelectedItem));
+                    RaisePropertyChanged(nameof(SelectedItems));
+                }
             }
         }
 
@@ -785,6 +790,7 @@ namespace Avalonia.Controls
         {
             if (_operationCount++ == 0)
             {
+                _oldAnchorIndex = AnchorIndex;
                 _rootNode.BeginOperation();
             }
         }
@@ -808,13 +814,16 @@ namespace Avalonia.Controls
                     var changeSet = new SelectionModelChangeSet(changes);
                     e = changeSet.CreateEventArgs();
                 }
-            }
 
-            OnSelectionChanged(e);
+                OnSelectionChanged(e);
+                
+                if (_oldAnchorIndex != AnchorIndex)
+                {
+                    RaisePropertyChanged(nameof(AnchorIndex));
+                }
 
-            if (_operationCount == 0)
-            {
                 _rootNode.Cleanup();
+                _oldAnchorIndex = default;
             }
         }
 
diff --git a/tests/Avalonia.Controls.UnitTests/SelectionModelTests.cs b/tests/Avalonia.Controls.UnitTests/SelectionModelTests.cs
index 246ff723a1..ebf9c40012 100644
--- a/tests/Avalonia.Controls.UnitTests/SelectionModelTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/SelectionModelTests.cs
@@ -1458,6 +1458,60 @@ namespace Avalonia.Controls.UnitTests
             Assert.Equal(1, raised);
         }
 
+        [Fact]
+        public void Batch_Update_Does_Not_Raise_PropertyChanged_Until_Operation_Finished()
+        {
+            var data = new[] { "foo", "bar", "baz", "qux" };
+            var target = new SelectionModel { Source = data };
+            var raised = 0;
+
+            target.SelectedIndex = new IndexPath(1);
+
+            Assert.Equal(new IndexPath(1), target.AnchorIndex);
+
+            target.PropertyChanged += (s, e) => ++raised;
+
+            using (target.Update())
+            {
+                target.ClearSelection();
+
+                Assert.Equal(0, raised);
+
+                target.AnchorIndex = new IndexPath(2);
+
+                Assert.Equal(0, raised);
+
+                target.SelectedIndex = new IndexPath(3);
+
+                Assert.Equal(0, raised);
+            }
+
+            Assert.Equal(new IndexPath(3), target.AnchorIndex);
+            Assert.Equal(5, raised);
+        }
+
+        [Fact]
+        public void Batch_Update_Does_Not_Raise_PropertyChanged_If_Nothing_Changed()
+        {
+            var data = new[] { "foo", "bar", "baz", "qux" };
+            var target = new SelectionModel { Source = data };
+            var raised = 0;
+
+            target.SelectedIndex = new IndexPath(1);
+
+            Assert.Equal(new IndexPath(1), target.AnchorIndex);
+
+            target.PropertyChanged += (s, e) => ++raised;
+
+            using (target.Update())
+            {
+                target.ClearSelection();
+                target.SelectedIndex = new IndexPath(1);
+            }
+
+            Assert.Equal(0, raised);
+        }
+
         [Fact]
         public void AutoSelect_Selects_When_Enabled()
         {

From 094462639e10fe743786438bffa847abaaa64a35 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 14 May 2020 07:59:38 +0200
Subject: [PATCH 26/32] Add StackLayout.DisableVirtualization

And a couple of updates to `ItemsRepeater`.

Ported from https://github.com/microsoft/microsoft-ui-xaml/commit/f3862ecf86530a9341002fcab287ae1dcfccaf53
---
 .../Repeater/ItemsRepeater.cs                 | 28 ++++++++++++++-----
 src/Avalonia.Layout/FlowLayoutAlgorithm.cs    | 10 ++++---
 src/Avalonia.Layout/StackLayout.cs            | 16 +++++++++++
 src/Avalonia.Layout/UniformGridLayout.cs      |  1 +
 4 files changed, 44 insertions(+), 11 deletions(-)

diff --git a/src/Avalonia.Controls/Repeater/ItemsRepeater.cs b/src/Avalonia.Controls/Repeater/ItemsRepeater.cs
index 086599d0bb..12fba12c8c 100644
--- a/src/Avalonia.Controls/Repeater/ItemsRepeater.cs
+++ b/src/Avalonia.Controls/Repeater/ItemsRepeater.cs
@@ -10,6 +10,7 @@ using Avalonia.Controls.Templates;
 using Avalonia.Data;
 using Avalonia.Input;
 using Avalonia.Layout;
+using Avalonia.VisualTree;
 
 namespace Avalonia.Controls
 {
@@ -379,14 +380,19 @@ namespace Avalonia.Controls
         {
             if (property == ItemsProperty)
             {
+                var oldEnumerable = oldValue.GetValueOrDefault<IEnumerable>();
                 var newEnumerable = newValue.GetValueOrDefault<IEnumerable>();
-                var newDataSource = newEnumerable as ItemsSourceView;
-                if (newEnumerable != null && newDataSource == null)
+
+                if (oldEnumerable != newEnumerable)
                 {
-                    newDataSource = new ItemsSourceView(newEnumerable);
-                }
+                    var newDataSource = newEnumerable as ItemsSourceView;
+                    if (newEnumerable != null && newDataSource == null)
+                    {
+                        newDataSource = new ItemsSourceView(newEnumerable);
+                    }
 
-                OnDataSourcePropertyChanged(ItemsSourceView, newDataSource);
+                    OnDataSourcePropertyChanged(ItemsSourceView, newDataSource);
+                }
             }
             else if (property == ItemTemplateProperty)
             {
@@ -431,8 +437,16 @@ namespace Avalonia.Controls
 
         private int GetElementIndexImpl(IControl element)
         {
-            var virtInfo = TryGetVirtualizationInfo(element);
-            return _viewManager.GetElementIndex(virtInfo);
+            // Verify that element is actually a child of this ItemsRepeater
+            var parent = element.GetVisualParent();
+            
+            if (parent == this)
+            {
+                var virtInfo = TryGetVirtualizationInfo(element);
+                return _viewManager.GetElementIndex(virtInfo);
+            }
+
+            return -1;
         }
 
         private IControl GetElementFromIndexImpl(int index)
diff --git a/src/Avalonia.Layout/FlowLayoutAlgorithm.cs b/src/Avalonia.Layout/FlowLayoutAlgorithm.cs
index 7f44c80a64..0d64f8dfd5 100644
--- a/src/Avalonia.Layout/FlowLayoutAlgorithm.cs
+++ b/src/Avalonia.Layout/FlowLayoutAlgorithm.cs
@@ -74,6 +74,7 @@ namespace Avalonia.Layout
             double lineSpacing,
             int maxItemsPerLine,
             ScrollOrientation orientation,
+            bool disableVirtualization,
             string layoutId)
         {
             _orientation.ScrollOrientation = orientation;
@@ -95,14 +96,14 @@ namespace Avalonia.Layout
             _elementManager.OnBeginMeasure(orientation);
 
             int anchorIndex = GetAnchorIndex(availableSize, isWrapping, minItemSpacing, layoutId);
-            Generate(GenerateDirection.Forward, anchorIndex, availableSize, minItemSpacing, lineSpacing, maxItemsPerLine, layoutId);
-            Generate(GenerateDirection.Backward, anchorIndex, availableSize, minItemSpacing, lineSpacing, maxItemsPerLine, layoutId);
+            Generate(GenerateDirection.Forward, anchorIndex, availableSize, minItemSpacing, lineSpacing, maxItemsPerLine, disableVirtualization, layoutId);
+            Generate(GenerateDirection.Backward, anchorIndex, availableSize, minItemSpacing, lineSpacing, maxItemsPerLine, disableVirtualization, layoutId);
             if (isWrapping && IsReflowRequired())
             {
                 var firstElementBounds = _elementManager.GetLayoutBoundsForRealizedIndex(0);
                 _orientation.SetMinorStart(ref firstElementBounds, 0);
                 _elementManager.SetLayoutBoundsForRealizedIndex(0, firstElementBounds);
-                Generate(GenerateDirection.Forward, 0 /*anchorIndex*/, availableSize, minItemSpacing, lineSpacing, maxItemsPerLine, layoutId);
+                Generate(GenerateDirection.Forward, 0 /*anchorIndex*/, availableSize, minItemSpacing, lineSpacing, maxItemsPerLine, disableVirtualization, layoutId);
             }
 
             RaiseLineArranged();
@@ -273,6 +274,7 @@ namespace Avalonia.Layout
             double minItemSpacing,
             double lineSpacing,
             int maxItemsPerLine,
+            bool disableVirtualization,
             string layoutId)
         {
             if (anchorIndex != -1)
@@ -288,7 +290,7 @@ namespace Avalonia.Layout
                 bool lineNeedsReposition = false;
 
                 while (_elementManager.IsIndexValidInData(currentIndex) &&
-                    ShouldContinueFillingUpSpace(previousIndex, direction))
+                    (disableVirtualization || ShouldContinueFillingUpSpace(previousIndex, direction)))
                 {
                     // Ensure layout element.
                     _elementManager.EnsureElementRealized(direction == GenerateDirection.Forward, currentIndex, layoutId);
diff --git a/src/Avalonia.Layout/StackLayout.cs b/src/Avalonia.Layout/StackLayout.cs
index 9b8eb4814e..b383c205f9 100644
--- a/src/Avalonia.Layout/StackLayout.cs
+++ b/src/Avalonia.Layout/StackLayout.cs
@@ -14,6 +14,12 @@ namespace Avalonia.Layout
     /// </summary>
     public class StackLayout : VirtualizingLayout, IFlowLayoutAlgorithmDelegates
     {
+        /// <summary>
+        /// Defines the <see cref="DisableVirtualization"/> property.
+        /// </summary>
+        public static readonly StyledProperty<bool> DisableVirtualizationProperty =
+            AvaloniaProperty.Register<StackLayout, bool>(nameof(DisableVirtualization));
+
         /// <summary>
         /// Defines the <see cref="Orientation"/> property.
         /// </summary>
@@ -36,6 +42,15 @@ namespace Avalonia.Layout
             LayoutId = "StackLayout";
         }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether virtualization is disabled on the layout.
+        /// </summary>
+        public bool DisableVirtualization
+        {
+            get => GetValue(DisableVirtualizationProperty);
+            set => SetValue(DisableVirtualizationProperty, value);
+        }
+
         /// <summary>
         /// Gets or sets the axis along which items are laid out.
         /// </summary>
@@ -270,6 +285,7 @@ namespace Avalonia.Layout
                 Spacing,
                 int.MaxValue,
                 _orientation.ScrollOrientation,
+                DisableVirtualization,
                 LayoutId);
 
             return new Size(desiredSize.Width, desiredSize.Height);
diff --git a/src/Avalonia.Layout/UniformGridLayout.cs b/src/Avalonia.Layout/UniformGridLayout.cs
index ee9cff4a01..d565fae074 100644
--- a/src/Avalonia.Layout/UniformGridLayout.cs
+++ b/src/Avalonia.Layout/UniformGridLayout.cs
@@ -433,6 +433,7 @@ namespace Avalonia.Layout
                 LineSpacing,
                 _maximumRowsOrColumns,
                 _orientation.ScrollOrientation,
+                false,
                 LayoutId);
 
             // If after Measure the first item is in the realization rect, then we revoke grid state's ownership,

From 6eb7f5b034aabb41edb2419cee09b524f5d0c0d2 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 14 May 2020 08:09:26 +0200
Subject: [PATCH 27/32] Fix issue with multiple resets causing a crash due to
 duplicate keys.

Ported from https://github.com/microsoft/microsoft-ui-xaml/commit/464a4482772bd54f2b72cbaa8012704649120b32
---
 src/Avalonia.Controls/Repeater/ViewManager.cs | 36 +++++++++++++------
 1 file changed, 26 insertions(+), 10 deletions(-)

diff --git a/src/Avalonia.Controls/Repeater/ViewManager.cs b/src/Avalonia.Controls/Repeater/ViewManager.cs
index 7d005a30b4..4ed9cb3333 100644
--- a/src/Avalonia.Controls/Repeater/ViewManager.cs
+++ b/src/Avalonia.Controls/Repeater/ViewManager.cs
@@ -388,19 +388,24 @@ namespace Avalonia.Controls
                     }
 
                 case NotifyCollectionChangedAction.Reset:
-                    if (_owner.ItemsSourceView.HasKeyIndexMapping)
+                    // If we get multiple resets back to back before
+                    // running layout, we dont have to clear all the elements again.
+                    if (!_isDataSourceStableResetPending)
                     {
-                        _isDataSourceStableResetPending = true;
-                    }
+                        if (_owner.ItemsSourceView.HasKeyIndexMapping)
+                        {
+                            _isDataSourceStableResetPending = true;
+                        }
 
-                    // Walk through all the elements and make sure they are cleared, they will go into
-                    // the stable id reset pool.
-                    foreach (var element in _owner.Children)
-                    {
-                        var virtInfo = ItemsRepeater.GetVirtualizationInfo(element);
-                        if (virtInfo.IsRealized && virtInfo.AutoRecycleCandidate)
+                        // Walk through all the elements and make sure they are cleared, they will go into
+                        // the stable id reset pool.
+                        foreach (var element in _owner.Children)
                         {
-                            _owner.ClearElementImpl(element);
+                            var virtInfo = ItemsRepeater.GetVirtualizationInfo(element);
+                            if (virtInfo.IsRealized && virtInfo.AutoRecycleCandidate)
+                            {
+                                _owner.ClearElementImpl(element);
+                            }
                         }
                     }
 
@@ -441,6 +446,9 @@ namespace Avalonia.Controls
                 }
 
                 _resetPool.Clear();
+
+                // Flush the realized indices once the stable reset pool is cleared to start fresh.
+                InvalidateRealizedIndicesHeldByLayout();
             }
         }
 
@@ -498,6 +506,10 @@ namespace Avalonia.Controls
                     var virtInfo = ItemsRepeater.GetVirtualizationInfo(element);
                     virtInfo.MoveOwnershipToLayoutFromUniqueIdResetPool();
                     UpdateElementIndex(element, virtInfo, index);
+
+                    // Update realized indices
+                    _firstRealizedElementIndexHeldByLayout = Math.Min(_firstRealizedElementIndexHeldByLayout, index);
+                    _lastRealizedElementIndexHeldByLayout = Math.Max(_lastRealizedElementIndexHeldByLayout, index);
                 }
             }
 
@@ -519,6 +531,10 @@ namespace Avalonia.Controls
                     _pinnedPool.RemoveAt(i);
                     element = elementInfo.PinnedElement;
                     elementInfo.VirtualizationInfo.MoveOwnershipToLayoutFromPinnedPool();
+
+                    // Update realized indices
+                    _firstRealizedElementIndexHeldByLayout = Math.Min(_firstRealizedElementIndexHeldByLayout, index);
+                    _lastRealizedElementIndexHeldByLayout = Math.Max(_lastRealizedElementIndexHeldByLayout, index);
                     break;
                 }
             }

From 310d594461463a0010f9cee4c65391cee2577be5 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 14 May 2020 08:34:33 +0200
Subject: [PATCH 28/32] StackLayout incorrect sizing bug

Ported from https://github.com/microsoft/microsoft-ui-xaml/commit/c621498e61909850f1d7d0e760a296355f75d58f
---
 src/Avalonia.Layout/StackLayout.cs      | 4 ++--
 src/Avalonia.Layout/StackLayoutState.cs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Avalonia.Layout/StackLayout.cs b/src/Avalonia.Layout/StackLayout.cs
index b383c205f9..d11875b2c1 100644
--- a/src/Avalonia.Layout/StackLayout.cs
+++ b/src/Avalonia.Layout/StackLayout.cs
@@ -277,6 +277,8 @@ namespace Avalonia.Layout
 
         protected internal override Size MeasureOverride(VirtualizingLayoutContext context, Size availableSize)
         {
+            ((StackLayoutState)context.LayoutState).OnMeasureStart();
+
             var desiredSize = GetFlowAlgorithm(context).Measure(
                 availableSize,
                 context,
@@ -300,8 +302,6 @@ namespace Avalonia.Layout
                FlowLayoutAlgorithm.LineAlignment.Start,
                LayoutId);
 
-            ((StackLayoutState)context.LayoutState).OnArrangeLayoutEnd();
-
             return new Size(value.Width, value.Height);
         }
 
diff --git a/src/Avalonia.Layout/StackLayoutState.cs b/src/Avalonia.Layout/StackLayoutState.cs
index 05ad9bca8e..e6164e02e6 100644
--- a/src/Avalonia.Layout/StackLayoutState.cs
+++ b/src/Avalonia.Layout/StackLayoutState.cs
@@ -56,6 +56,6 @@ namespace Avalonia.Layout
             MaxArrangeBounds = Math.Max(MaxArrangeBounds, minorSize);
         }
 
-        internal void OnArrangeLayoutEnd() => MaxArrangeBounds = 0;
+        internal void OnMeasureStart() => MaxArrangeBounds = 0;
     }
 }

From c3635302b5c142d21c8ff5f222b981263464176a Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Thu, 14 May 2020 13:03:32 +0300
Subject: [PATCH 29/32] Changed box shadow drawing APIs a bit

---
 src/Avalonia.Visuals/Media/BoxShadows.cs     | 4 +---
 src/Avalonia.Visuals/Media/DrawingContext.cs | 6 +++---
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/Avalonia.Visuals/Media/BoxShadows.cs b/src/Avalonia.Visuals/Media/BoxShadows.cs
index fd187f6409..9e4d6aacb0 100644
--- a/src/Avalonia.Visuals/Media/BoxShadows.cs
+++ b/src/Avalonia.Visuals/Media/BoxShadows.cs
@@ -21,7 +21,7 @@ namespace Avalonia.Media
         {
             _first = shadow;
             _list = null;
-            Count = 1;
+            Count = _first.IsEmpty ? 0 : 1;
         }
 
         public BoxShadows(BoxShadow first, BoxShadow[] rest)
@@ -105,8 +105,6 @@ namespace Avalonia.Media
                 return false;
             }
         }
-
-        public static implicit operator BoxShadows(BoxShadow shadow) => new BoxShadows(shadow);
         
         public bool Equals(BoxShadows other)
         {
diff --git a/src/Avalonia.Visuals/Media/DrawingContext.cs b/src/Avalonia.Visuals/Media/DrawingContext.cs
index 4df26c470d..1a45b8342a 100644
--- a/src/Avalonia.Visuals/Media/DrawingContext.cs
+++ b/src/Avalonia.Visuals/Media/DrawingContext.cs
@@ -141,13 +141,13 @@ namespace Avalonia.Media
         /// <param name="radiusY">The radius in the Y dimension of the rounded corners.
         ///     This value will be clamped to the range of 0 to Height/2
         /// </param>
-        /// <param name="boxShadow">Box shadow effect parameters</param>
+        /// <param name="boxShadows">Box shadow effect parameters</param>
         /// <remarks>
         /// The brush and the pen can both be null. If the brush is null, then no fill is performed.
         /// If the pen is null, then no stoke is performed. If both the pen and the brush are null, then the drawing is not visible.
         /// </remarks>
         public void DrawRectangle(IBrush brush, IPen pen, Rect rect, double radiusX = 0, double radiusY = 0,
-            BoxShadow boxShadow = default)
+            BoxShadows boxShadows = default)
         {
             if (brush == null && !PenIsVisible(pen))
             {
@@ -164,7 +164,7 @@ namespace Avalonia.Media
                 radiusY = Math.Min(radiusY, rect.Height / 2);
             }
 
-            PlatformImpl.DrawRectangle(brush, pen, new RoundedRect(rect, radiusX, radiusY), boxShadow);
+            PlatformImpl.DrawRectangle(brush, pen, new RoundedRect(rect, radiusX, radiusY), boxShadows);
         }
 
         /// <summary>

From 11d0ca56de6c040b1b2f8223dfda54ffbe6bf99a Mon Sep 17 00:00:00 2001
From: Dan Walmsley <dan@walms.co.uk>
Date: Thu, 14 May 2020 09:16:38 -0300
Subject: [PATCH 30/32] fix timespan in render demo.

---
 samples/RenderDemo/Controls/LineBoundsDemoControl.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/samples/RenderDemo/Controls/LineBoundsDemoControl.cs b/samples/RenderDemo/Controls/LineBoundsDemoControl.cs
index 0e0b3d6142..cc847a594d 100644
--- a/samples/RenderDemo/Controls/LineBoundsDemoControl.cs
+++ b/samples/RenderDemo/Controls/LineBoundsDemoControl.cs
@@ -17,7 +17,7 @@ namespace RenderDemo.Controls
         public LineBoundsDemoControl()
         {
             var timer = new DispatcherTimer();
-            timer.Interval = TimeSpan.FromSeconds(1 / 60);
+            timer.Interval = TimeSpan.FromSeconds(1 / 60.0);
             timer.Tick += (sender, e) => Angle += Math.PI / 360;
             timer.Start();
         }

From 92e63f31c8e9a8f24be968a63a72b89ca420a438 Mon Sep 17 00:00:00 2001
From: danwalmsley <dan@walms.co.uk>
Date: Thu, 14 May 2020 13:21:37 -0300
Subject: [PATCH 31/32] Update build.md

---
 Documentation/build.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Documentation/build.md b/Documentation/build.md
index 56b028206d..8c2ef57b54 100644
--- a/Documentation/build.md
+++ b/Documentation/build.md
@@ -36,7 +36,7 @@ Avalonia requires [CastXML](https://github.com/CastXML/CastXML) for XML processi
 
 On macOS:
 ```
-brew install castxml
+brew install https://raw.githubusercontent.com/Homebrew/homebrew-core/8a004a91a7fcd3f6620d5b01b6541ff0a640ffba/Formula/castxml.rb
 ```
 
 On Debian based Linux (Debian, Ubuntu, Mint, etc):

From 949f33227f2913369b671be18611df64cf34c907 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Thu, 14 May 2020 22:00:49 +0200
Subject: [PATCH 32/32] Unwrap TargetInvocationException.

To provide a better error message to the designer.
---
 .../Remote/RemoteDesignerEntryPoint.cs        | 10 +-------
 .../DesignMessages.cs                         | 24 +++++++++++++++++++
 2 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/src/Avalonia.DesignerSupport/Remote/RemoteDesignerEntryPoint.cs b/src/Avalonia.DesignerSupport/Remote/RemoteDesignerEntryPoint.cs
index 44d9a94f5a..e61fe82c41 100644
--- a/src/Avalonia.DesignerSupport/Remote/RemoteDesignerEntryPoint.cs
+++ b/src/Avalonia.DesignerSupport/Remote/RemoteDesignerEntryPoint.cs
@@ -234,18 +234,10 @@ namespace Avalonia.DesignerSupport.Remote
                 }
                 catch (Exception e)
                 {
-                    var xmlException = e as XmlException;
-                    
                     s_transport.Send(new UpdateXamlResultMessage
                     {
                         Error = e.ToString(),
-                        Exception = new ExceptionDetails
-                        {
-                            ExceptionType = e.GetType().FullName,
-                            Message = e.Message.ToString(),
-                            LineNumber = xmlException?.LineNumber,
-                            LinePosition = xmlException?.LinePosition,
-                        }
+                        Exception = new ExceptionDetails(e),
                     });
                 }
             }
diff --git a/src/Avalonia.Remote.Protocol/DesignMessages.cs b/src/Avalonia.Remote.Protocol/DesignMessages.cs
index 5ff16c574d..5c769ad48c 100644
--- a/src/Avalonia.Remote.Protocol/DesignMessages.cs
+++ b/src/Avalonia.Remote.Protocol/DesignMessages.cs
@@ -1,4 +1,7 @@
 using System;
+using System.Reflection;
+using System.Runtime.ExceptionServices;
+using System.Xml;
 
 namespace Avalonia.Remote.Protocol.Designer
 {
@@ -26,6 +29,27 @@ namespace Avalonia.Remote.Protocol.Designer
     
     public class ExceptionDetails
     {
+        public ExceptionDetails()
+        {
+        }
+
+        public ExceptionDetails(Exception e)
+        {
+            if (e is TargetInvocationException)
+            {
+                e = e.InnerException;
+            }
+
+            ExceptionType = e.GetType().Name;
+            Message = e.Message;
+
+            if (e is XmlException xml)
+            {
+                LineNumber = xml.LineNumber;
+                LinePosition = xml.LinePosition;
+            }
+        }
+
         public string ExceptionType { get; set; }
         public string Message { get; set; }
         public int? LineNumber { get; set; }