From 7f0c502c296e5936385a36dd99e3e97ad0cb5ea4 Mon Sep 17 00:00:00 2001
From: Andrey Kunchev <donandren@gmail.com>
Date: Mon, 23 Mar 2020 12:51:26 +0200
Subject: [PATCH 01/29] add simple unit test for multibinding

---
 .../AvaloniaObjectTests_MultiBinding.cs       | 59 +++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs

diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
new file mode 100644
index 0000000000..30693e2cb3
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
@@ -0,0 +1,59 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using Avalonia.Data;
+using Avalonia.Data.Converters;
+using Xunit;
+
+namespace Avalonia.Base.UnitTests
+{
+    public class AvaloniaObjectTests_MultiBinding
+    {
+        [Fact]
+        public void Should_Update()
+        {
+            var target = new Class1();
+
+            var b = new Subject<object>();
+
+            var mb = new MultiBinding()
+            {
+                Converter = StringJoinConverter,
+                Bindings = new[]
+                {
+                    b.ToBinding()
+                }
+            };
+            target.Bind(Class1.FooProperty, mb);
+
+            Assert.Equal(null, target.Foo);
+
+            b.OnNext("Foo");
+
+            Assert.Equal("Foo", target.Foo);
+
+            b.OnNext("Bar");
+
+            Assert.Equal("Bar", target.Foo);
+        }
+
+        private static IMultiValueConverter StringJoinConverter = new FuncMultiValueConverter<object, string>(v => string.Join(",", v.ToArray()));
+
+        private class Class1 : AvaloniaObject
+        {
+            public static readonly StyledProperty<string> FooProperty =
+                AvaloniaProperty.Register<Class1, string>("Foo");
+
+            public string Foo
+            {
+                get => GetValue(FooProperty);
+                set => SetValue(FooProperty, value);
+            }
+        }
+    }
+}

From 613ba3ffd2e207220aa56ab4bd2006210a63119c Mon Sep 17 00:00:00 2001
From: Andrey Kunchev <donandren@gmail.com>
Date: Mon, 23 Mar 2020 12:52:09 +0200
Subject: [PATCH 02/29] add another test for multibinding

---
 .../AvaloniaObjectTests_MultiBinding.cs       | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
index 30693e2cb3..19ffb014d4 100644
--- a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
+++ b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
@@ -42,6 +42,35 @@ namespace Avalonia.Base.UnitTests
             Assert.Equal("Bar", target.Foo);
         }
 
+        [Fact]
+        public void Should_Update_With_Multiple_Bindings()
+        {
+            var target = new Class1();
+
+            var bindings = Enumerable.Range(0, 3).Select(i => new BehaviorSubject<object>("Empty")).ToArray();
+
+            var mb = new MultiBinding()
+            {
+                Converter = StringJoinConverter,
+                Bindings = bindings.Select(b => b.ToBinding()).ToArray()
+            };
+            target.Bind(Class1.FooProperty, mb);
+
+            Assert.Equal("Empty,Empty,Empty", target.Foo);
+
+            bindings[0].OnNext("Foo");
+
+            Assert.Equal("Foo,Empty,Empty", target.Foo);
+
+            bindings[1].OnNext("Bar");
+
+            Assert.Equal("Foo,Bar,Empty", target.Foo);
+
+            bindings[2].OnNext("Baz");
+
+            Assert.Equal("Foo,Bar,Baz", target.Foo);
+        }
+
         private static IMultiValueConverter StringJoinConverter = new FuncMultiValueConverter<object, string>(v => string.Join(",", v.ToArray()));
 
         private class Class1 : AvaloniaObject

From 50deb04e7ab060e42c078a51c30e5b529019dbb9 Mon Sep 17 00:00:00 2001
From: Andrey Kunchev <donandren@gmail.com>
Date: Mon, 23 Mar 2020 12:56:25 +0200
Subject: [PATCH 03/29] add failing unit test for #3692

---
 .../AvaloniaObjectTests_MultiBinding.cs       | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
index 19ffb014d4..8560966fb7 100644
--- a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
+++ b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
@@ -71,6 +71,34 @@ namespace Avalonia.Base.UnitTests
             Assert.Equal("Foo,Bar,Baz", target.Foo);
         }
 
+        [Fact]
+        public void Should_Update_When_Null_Value_In_Bindings()
+        {
+            var target = new Class1();
+
+            var b = new Subject<object>();
+
+            var mb = new MultiBinding()
+            {
+                Converter = StringJoinConverter,
+                Bindings = new[]
+                {
+                    b.ToBinding()
+                }
+            };
+            target.Bind(Class1.FooProperty, mb);
+
+            Assert.Equal(null, target.Foo);
+
+            b.OnNext("Foo");
+
+            Assert.Equal("Foo", target.Foo);
+
+            b.OnNext(null);
+
+            Assert.Equal("", target.Foo);
+        }
+
         private static IMultiValueConverter StringJoinConverter = new FuncMultiValueConverter<object, string>(v => string.Join(",", v.ToArray()));
 
         private class Class1 : AvaloniaObject

From ec92b90e81601a040fd9d25d0b70d5aebeb49e7c Mon Sep 17 00:00:00 2001
From: Andrey Kunchev <donandren@gmail.com>
Date: Mon, 23 Mar 2020 12:57:27 +0200
Subject: [PATCH 04/29] add a test for multibinding with StringFormat

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

diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
index 8560966fb7..ab413dd550 100644
--- a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
+++ b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
@@ -99,6 +99,30 @@ namespace Avalonia.Base.UnitTests
             Assert.Equal("", target.Foo);
         }
 
+        [Fact]
+        public void Should_Update_When_Null_Value_In_Bindings_With_StringFormat()
+        {
+            var target = new Class1();
+
+            var b = new Subject<object>();
+
+            var mb = new MultiBinding()
+            {
+                StringFormat = "Converted: {0}",
+                Bindings = new[]
+                {
+                    b.ToBinding()
+                }
+            };
+            target.Bind(Class1.FooProperty, mb);
+
+            Assert.Equal(null, target.Foo);
+            b.OnNext("Foo");
+            Assert.Equal("Converted: Foo", target.Foo);
+            b.OnNext(null);
+            Assert.Equal("Converted: ", target.Foo);
+        }
+
         private static IMultiValueConverter StringJoinConverter = new FuncMultiValueConverter<object, string>(v => string.Join(",", v.ToArray()));
 
         private class Class1 : AvaloniaObject

From 3dc5b8bda19f1031e95760f4964098e4b01c5f64 Mon Sep 17 00:00:00 2001
From: Andrey Kunchev <donandren@gmail.com>
Date: Mon, 23 Mar 2020 12:59:30 +0200
Subject: [PATCH 05/29] add failing test for the core reason of the issue #3692

---
 .../AvaloniaObjectTests_MultiBinding.cs       | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
index ab413dd550..757160a0a4 100644
--- a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
+++ b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
@@ -123,6 +123,44 @@ namespace Avalonia.Base.UnitTests
             Assert.Equal("Converted: ", target.Foo);
         }
 
+        [Fact]
+        public void MultiValueConverter_Should_Not_Skip_Valid_Null_ReferenceType_Value()
+        {
+            var target = new FuncMultiValueConverter<string, string>(v => string.Join(",", v.ToArray()));
+
+            object value = target.Convert(new[] { "Foo", "Bar", "Baz" }, typeof(string), null, CultureInfo.InvariantCulture);
+
+            Assert.Equal("Foo,Bar,Baz", value);
+
+            value = target.Convert(new[] { null, "Bar", "Baz" }, typeof(string), null, CultureInfo.InvariantCulture);
+
+            Assert.Equal(",Bar,Baz", value);
+        }
+
+        [Fact]
+        public void MultiValueConverter_Should_Not_Skip_Valid_Default_ValueType_Value()
+        {
+            var target = new FuncMultiValueConverter<StringValueTypeWrapper, string>(v => string.Join(",", v.ToArray()));
+
+            IList<object> create(string[] values) =>
+                values.Select(v => (object)(v != null ? new StringValueTypeWrapper() { Value = v } : default)).ToList();
+
+            object value = target.Convert(create(new[] { "Foo", "Bar", "Baz" }), typeof(string), null, CultureInfo.InvariantCulture);
+
+            Assert.Equal("Foo,Bar,Baz", value);
+
+            value = target.Convert(create(new[] { null, "Bar", "Baz" }), typeof(string), null, CultureInfo.InvariantCulture);
+
+            Assert.Equal(",Bar,Baz", value);
+        }
+
+        private struct StringValueTypeWrapper
+        {
+            public string Value;
+
+            public override string ToString() => Value;
+        }
+
         private static IMultiValueConverter StringJoinConverter = new FuncMultiValueConverter<object, string>(v => string.Join(",", v.ToArray()));
 
         private class Class1 : AvaloniaObject

From 6e54db32e94d1166fa74b0391eafe1ddd6a49d9b Mon Sep 17 00:00:00 2001
From: Andrey Kunchev <donandren@gmail.com>
Date: Mon, 23 Mar 2020 13:22:58 +0200
Subject: [PATCH 06/29] fix #3692

---
 .../Data/Converters/FuncMultiValueConverter.cs | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Base/Data/Converters/FuncMultiValueConverter.cs b/src/Avalonia.Base/Data/Converters/FuncMultiValueConverter.cs
index 6e1c4cb0e3..887641b5c3 100644
--- a/src/Avalonia.Base/Data/Converters/FuncMultiValueConverter.cs
+++ b/src/Avalonia.Base/Data/Converters/FuncMultiValueConverter.cs
@@ -30,7 +30,23 @@ namespace Avalonia.Data.Converters
         /// <inheritdoc/>
         public object Convert(IList<object> values, Type targetType, object parameter, CultureInfo culture)
         {
-            var converted = values.OfType<TIn>().ToList();
+            //standard OfType skip null values, even they are valid for the Type
+            static IEnumerable<TIn> OfTypeWithDefaultSupport(IList<object> list)
+            {
+                foreach (object obj in list)
+                {
+                    if (obj is TIn result)
+                    {
+                        yield return result;
+                    }
+                    else if (Equals(obj, default(TIn)))
+                    {
+                        yield return default(TIn);
+                    }
+                }
+            }
+
+            var converted = OfTypeWithDefaultSupport(values).ToList();
 
             if (converted.Count == values.Count)
             {

From 764e7aff01a276677c96614bbb89f9436ce1d499 Mon Sep 17 00:00:00 2001
From: Dariusz Komosinski <darek.komosinski@gmail.com>
Date: Mon, 23 Mar 2020 21:11:00 +0100
Subject: [PATCH 07/29] Initial refactor of win32 window.

---
 samples/ControlCatalog/Pages/DialogsPage.xaml |    1 +
 .../ControlCatalog/Pages/DialogsPage.xaml.cs  |   31 +-
 src/Avalonia.Controls/Window.cs               |    2 +
 .../Avalonia.Win32/WindowImpl.WndProc.cs      |  436 +++++++
 src/Windows/Avalonia.Win32/WindowImpl.cs      | 1002 ++++++-----------
 5 files changed, 784 insertions(+), 688 deletions(-)
 create mode 100644 src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs

diff --git a/samples/ControlCatalog/Pages/DialogsPage.xaml b/samples/ControlCatalog/Pages/DialogsPage.xaml
index 60f8e3656e..1ed5c0cbfd 100644
--- a/samples/ControlCatalog/Pages/DialogsPage.xaml
+++ b/samples/ControlCatalog/Pages/DialogsPage.xaml
@@ -9,5 +9,6 @@
       <Button Name="DecoratedWindow">Decorated window</Button>
       <Button Name="DecoratedWindowDialog">Decorated window (dialog)</Button>
       <Button Name="Dialog">Dialog</Button>
+      <Button Name="DialogNoTaskbar">Dialog (No taskbar icon)</Button>
   </StackPanel>
 </UserControl>
diff --git a/samples/ControlCatalog/Pages/DialogsPage.xaml.cs b/samples/ControlCatalog/Pages/DialogsPage.xaml.cs
index d207689223..0e266dac2b 100644
--- a/samples/ControlCatalog/Pages/DialogsPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/DialogsPage.xaml.cs
@@ -61,14 +61,29 @@ namespace ControlCatalog.Pages
                 new DecoratedWindow().ShowDialog(GetWindow());
             };
             this.FindControl<Button>("Dialog").Click += delegate
-                {
-                    var window = new Window();
-                    window.Height = 200;
-                    window.Width = 200;
-                    window.Content = new TextBlock { Text = "Hello world!" };
-                    window.WindowStartupLocation = WindowStartupLocation.CenterOwner;
-                    window.ShowDialog(GetWindow());
-                };
+            {
+                var window = CreateSampleWindow();
+                window.Height = 200;
+                window.ShowDialog(GetWindow());
+            };
+            this.FindControl<Button>("DialogNoTaskbar").Click += delegate
+            {
+                var window = CreateSampleWindow();
+                window.Height = 200;
+                window.ShowInTaskbar = false;
+                window.ShowDialog(GetWindow());
+            };
+        }
+
+        private Window CreateSampleWindow()
+        {
+            var window = new Window();
+            window.Height = 200;
+            window.Width = 200;
+            window.Content = new TextBlock { Text = "Hello world!" };
+            window.WindowStartupLocation = WindowStartupLocation.CenterOwner;
+
+            return window;
         }
 
         Window GetWindow() => (Window)this.VisualRoot;
diff --git a/src/Avalonia.Controls/Window.cs b/src/Avalonia.Controls/Window.cs
index f4a3f05f03..c3ccadefb4 100644
--- a/src/Avalonia.Controls/Window.cs
+++ b/src/Avalonia.Controls/Window.cs
@@ -189,6 +189,8 @@ namespace Avalonia.Controls
             impl.WindowStateChanged = HandleWindowStateChanged;
             _maxPlatformClientSize = PlatformImpl?.MaxClientSize ?? default(Size);
             this.GetObservable(ClientSizeProperty).Skip(1).Subscribe(x => PlatformImpl?.Resize(x));
+
+            PlatformImpl?.ShowTaskbarIcon(ShowInTaskbar);
         }
 
         /// <summary>
diff --git a/src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs b/src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs
new file mode 100644
index 0000000000..d595ffbfbf
--- /dev/null
+++ b/src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs
@@ -0,0 +1,436 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Win32.Input;
+using static Avalonia.Win32.Interop.UnmanagedMethods;
+
+namespace Avalonia.Win32
+{
+    public partial class WindowImpl
+    {
+        [SuppressMessage("Microsoft.StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation",
+            Justification = "Using Win32 naming for consistency.")]
+        protected virtual unsafe IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
+        {
+            const double wheelDelta = 120.0;
+            uint timestamp = unchecked((uint)GetMessageTime());
+
+            RawInputEventArgs e = null;
+
+            switch ((WindowsMessage)msg)
+            {
+                case WindowsMessage.WM_ACTIVATE:
+                    var wa = (WindowActivate)(ToInt32(wParam) & 0xffff);
+
+                    switch (wa)
+                    {
+                        case WindowActivate.WA_ACTIVE:
+                        case WindowActivate.WA_CLICKACTIVE:
+                            Activated?.Invoke();
+                            break;
+
+                        case WindowActivate.WA_INACTIVE:
+                            Deactivated?.Invoke();
+                            break;
+                    }
+
+                    return IntPtr.Zero;
+
+                case WindowsMessage.WM_NCCALCSIZE:
+                    if (ToInt32(wParam) == 1 && !HasFullDecorations)
+                    {
+                        return IntPtr.Zero;
+                    }
+
+                    break;
+
+                case WindowsMessage.WM_CLOSE:
+                    bool? preventClosing = Closing?.Invoke();
+                    if (preventClosing == true)
+                    {
+                        return IntPtr.Zero;
+                    }
+
+                    break;
+
+                case WindowsMessage.WM_DESTROY:
+                    //Window doesn't exist anymore
+                    _hwnd = IntPtr.Zero;
+                    //Remove root reference to this class, so unmanaged delegate can be collected
+                    s_instances.Remove(this);
+                    Closed?.Invoke();
+                    if (_parent != null)
+                    {
+                        _parent._disabledBy.Remove(this);
+                        _parent.UpdateEnabled();
+                    }
+
+                    _mouseDevice.Dispose();
+                    _touchDevice?.Dispose();
+                    //Free other resources
+                    Dispose();
+                    return IntPtr.Zero;
+
+                case WindowsMessage.WM_DPICHANGED:
+                    var dpi = ToInt32(wParam) & 0xffff;
+                    var newDisplayRect = Marshal.PtrToStructure<RECT>(lParam);
+                    _scaling = dpi / 96.0;
+                    ScalingChanged?.Invoke(_scaling);
+                    SetWindowPos(hWnd,
+                        IntPtr.Zero,
+                        newDisplayRect.left,
+                        newDisplayRect.top,
+                        newDisplayRect.right - newDisplayRect.left,
+                        newDisplayRect.bottom - newDisplayRect.top,
+                        SetWindowPosFlags.SWP_NOZORDER |
+                        SetWindowPosFlags.SWP_NOACTIVATE);
+                    return IntPtr.Zero;
+
+                case WindowsMessage.WM_KEYDOWN:
+                case WindowsMessage.WM_SYSKEYDOWN:
+                    e = new RawKeyEventArgs(
+                        WindowsKeyboardDevice.Instance,
+                        timestamp,
+                        _owner,
+                        RawKeyEventType.KeyDown,
+                        KeyInterop.KeyFromVirtualKey(ToInt32(wParam), ToInt32(lParam)),
+                        WindowsKeyboardDevice.Instance.Modifiers);
+                    break;
+
+                case WindowsMessage.WM_MENUCHAR:
+                    // mute the system beep
+                    return (IntPtr)((Int32)MenuCharParam.MNC_CLOSE << 16);
+
+                case WindowsMessage.WM_KEYUP:
+                case WindowsMessage.WM_SYSKEYUP:
+                    e = new RawKeyEventArgs(
+                        WindowsKeyboardDevice.Instance,
+                        timestamp,
+                        _owner,
+                        RawKeyEventType.KeyUp,
+                        KeyInterop.KeyFromVirtualKey(ToInt32(wParam), ToInt32(lParam)),
+                        WindowsKeyboardDevice.Instance.Modifiers);
+                    break;
+                case WindowsMessage.WM_CHAR:
+                    // Ignore control chars
+                    if (ToInt32(wParam) >= 32)
+                    {
+                        e = new RawTextInputEventArgs(WindowsKeyboardDevice.Instance, timestamp, _owner,
+                            new string((char)ToInt32(wParam), 1));
+                    }
+
+                    break;
+
+                case WindowsMessage.WM_LBUTTONDOWN:
+                case WindowsMessage.WM_RBUTTONDOWN:
+                case WindowsMessage.WM_MBUTTONDOWN:
+                case WindowsMessage.WM_XBUTTONDOWN:
+                    if (ShouldIgnoreTouchEmulatedMessage())
+                        break;
+                    e = new RawPointerEventArgs(
+                        _mouseDevice,
+                        timestamp,
+                        _owner,
+                        (WindowsMessage)msg switch
+                        {
+                            WindowsMessage.WM_LBUTTONDOWN => RawPointerEventType.LeftButtonDown,
+                            WindowsMessage.WM_RBUTTONDOWN => RawPointerEventType.RightButtonDown,
+                            WindowsMessage.WM_MBUTTONDOWN => RawPointerEventType.MiddleButtonDown,
+                            WindowsMessage.WM_XBUTTONDOWN =>
+                            HighWord(ToInt32(wParam)) == 1 ?
+                                RawPointerEventType.XButton1Down :
+                                RawPointerEventType.XButton2Down
+                        },
+                        DipFromLParam(lParam), GetMouseModifiers(wParam));
+                    break;
+
+                case WindowsMessage.WM_LBUTTONUP:
+                case WindowsMessage.WM_RBUTTONUP:
+                case WindowsMessage.WM_MBUTTONUP:
+                case WindowsMessage.WM_XBUTTONUP:
+                    if (ShouldIgnoreTouchEmulatedMessage())
+                        break;
+                    e = new RawPointerEventArgs(
+                        _mouseDevice,
+                        timestamp,
+                        _owner,
+                        (WindowsMessage)msg switch
+                        {
+                            WindowsMessage.WM_LBUTTONUP => RawPointerEventType.LeftButtonUp,
+                            WindowsMessage.WM_RBUTTONUP => RawPointerEventType.RightButtonUp,
+                            WindowsMessage.WM_MBUTTONUP => RawPointerEventType.MiddleButtonUp,
+                            WindowsMessage.WM_XBUTTONUP =>
+                            HighWord(ToInt32(wParam)) == 1 ?
+                                RawPointerEventType.XButton1Up :
+                                RawPointerEventType.XButton2Up,
+                        },
+                        DipFromLParam(lParam), GetMouseModifiers(wParam));
+                    break;
+
+                case WindowsMessage.WM_MOUSEMOVE:
+                    if (ShouldIgnoreTouchEmulatedMessage())
+                        break;
+                    if (!_trackingMouse)
+                    {
+                        var tm = new TRACKMOUSEEVENT
+                        {
+                            cbSize = Marshal.SizeOf<TRACKMOUSEEVENT>(),
+                            dwFlags = 2,
+                            hwndTrack = _hwnd,
+                            dwHoverTime = 0,
+                        };
+
+                        TrackMouseEvent(ref tm);
+                    }
+
+                    e = new RawPointerEventArgs(
+                        _mouseDevice,
+                        timestamp,
+                        _owner,
+                        RawPointerEventType.Move,
+                        DipFromLParam(lParam), GetMouseModifiers(wParam));
+
+                    break;
+
+                case WindowsMessage.WM_MOUSEWHEEL:
+                    e = new RawMouseWheelEventArgs(
+                        _mouseDevice,
+                        timestamp,
+                        _owner,
+                        PointToClient(PointFromLParam(lParam)),
+                        new Vector(0, (ToInt32(wParam) >> 16) / wheelDelta), GetMouseModifiers(wParam));
+                    break;
+
+                case WindowsMessage.WM_MOUSEHWHEEL:
+                    e = new RawMouseWheelEventArgs(
+                        _mouseDevice,
+                        timestamp,
+                        _owner,
+                        PointToClient(PointFromLParam(lParam)),
+                        new Vector(-(ToInt32(wParam) >> 16) / wheelDelta, 0), GetMouseModifiers(wParam));
+                    break;
+
+                case WindowsMessage.WM_MOUSELEAVE:
+                    _trackingMouse = false;
+                    e = new RawPointerEventArgs(
+                        _mouseDevice,
+                        timestamp,
+                        _owner,
+                        RawPointerEventType.LeaveWindow,
+                        new Point(-1, -1), WindowsKeyboardDevice.Instance.Modifiers);
+                    break;
+
+                case WindowsMessage.WM_NCLBUTTONDOWN:
+                case WindowsMessage.WM_NCRBUTTONDOWN:
+                case WindowsMessage.WM_NCMBUTTONDOWN:
+                case WindowsMessage.WM_NCXBUTTONDOWN:
+                    e = new RawPointerEventArgs(
+                        _mouseDevice,
+                        timestamp,
+                        _owner,
+                        (WindowsMessage)msg switch
+                        {
+                            WindowsMessage.WM_NCLBUTTONDOWN => RawPointerEventType
+                                .NonClientLeftButtonDown,
+                            WindowsMessage.WM_NCRBUTTONDOWN => RawPointerEventType.RightButtonDown,
+                            WindowsMessage.WM_NCMBUTTONDOWN => RawPointerEventType.MiddleButtonDown,
+                            WindowsMessage.WM_NCXBUTTONDOWN =>
+                            HighWord(ToInt32(wParam)) == 1 ?
+                                RawPointerEventType.XButton1Down :
+                                RawPointerEventType.XButton2Down,
+                        },
+                        PointToClient(PointFromLParam(lParam)), GetMouseModifiers(wParam));
+                    break;
+                case WindowsMessage.WM_TOUCH:
+                    var touchInputCount = wParam.ToInt32();
+
+                    var pTouchInputs = stackalloc TOUCHINPUT[touchInputCount];
+                    var touchInputs = new Span<TOUCHINPUT>(pTouchInputs, touchInputCount);
+
+                    if (GetTouchInputInfo(lParam, (uint)touchInputCount, pTouchInputs,
+                        Marshal.SizeOf<TOUCHINPUT>()))
+                    {
+                        foreach (var touchInput in touchInputs)
+                        {
+                            Input?.Invoke(new RawTouchEventArgs(_touchDevice, touchInput.Time,
+                                _owner,
+                                touchInput.Flags.HasFlagCustom(TouchInputFlags.TOUCHEVENTF_UP) ?
+                                    RawPointerEventType.TouchEnd :
+                                    touchInput.Flags.HasFlagCustom(TouchInputFlags.TOUCHEVENTF_DOWN) ?
+                                        RawPointerEventType.TouchBegin :
+                                        RawPointerEventType.TouchUpdate,
+                                PointToClient(new PixelPoint(touchInput.X / 100, touchInput.Y / 100)),
+                                WindowsKeyboardDevice.Instance.Modifiers,
+                                touchInput.Id));
+                        }
+
+                        CloseTouchInputHandle(lParam);
+                        return IntPtr.Zero;
+                    }
+
+                    break;
+                case WindowsMessage.WM_NCPAINT:
+                    if (!HasFullDecorations)
+                    {
+                        return IntPtr.Zero;
+                    }
+
+                    break;
+
+                case WindowsMessage.WM_NCACTIVATE:
+                    if (!HasFullDecorations)
+                    {
+                        return new IntPtr(1);
+                    }
+
+                    break;
+
+                case WindowsMessage.WM_PAINT:
+                    using (_rendererLock.Lock())
+                    {
+                        PAINTSTRUCT ps;
+                        if (BeginPaint(_hwnd, out ps) != IntPtr.Zero)
+                        {
+                            var f = Scaling;
+                            var r = ps.rcPaint;
+                            Paint?.Invoke(new Rect(r.left / f, r.top / f, (r.right - r.left) / f,
+                                (r.bottom - r.top) / f));
+                            EndPaint(_hwnd, ref ps);
+                        }
+                    }
+
+                    return IntPtr.Zero;
+
+                case WindowsMessage.WM_SIZE:
+                    using (_rendererLock.Lock())
+                    {
+                        // Do nothing here, just block until the pending frame render is completed on the render thread
+                    }
+
+                    var size = (SizeCommand)wParam;
+
+                    if (Resized != null &&
+                        (size == SizeCommand.Restored ||
+                         size == SizeCommand.Maximized))
+                    {
+                        var clientSize = new Size(ToInt32(lParam) & 0xffff, ToInt32(lParam) >> 16);
+                        Resized(clientSize / Scaling);
+                    }
+
+                    var windowState = size == SizeCommand.Maximized ?
+                        WindowState.Maximized :
+                        (size == SizeCommand.Minimized ? WindowState.Minimized : WindowState.Normal);
+
+                    if (windowState != _lastWindowState)
+                    {
+                        _lastWindowState = windowState;
+                        WindowStateChanged?.Invoke(windowState);
+                    }
+
+                    return IntPtr.Zero;
+
+                case WindowsMessage.WM_MOVE:
+                    PositionChanged?.Invoke(new PixelPoint((short)(ToInt32(lParam) & 0xffff),
+                        (short)(ToInt32(lParam) >> 16)));
+                    return IntPtr.Zero;
+
+                case WindowsMessage.WM_GETMINMAXINFO:
+
+                    MINMAXINFO mmi = Marshal.PtrToStructure<MINMAXINFO>(lParam);
+
+                    if (_minSize.Width > 0)
+                        mmi.ptMinTrackSize.X =
+                            (int)((_minSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right);
+
+                    if (_minSize.Height > 0)
+                        mmi.ptMinTrackSize.Y =
+                            (int)((_minSize.Height * Scaling) + BorderThickness.Top + BorderThickness.Bottom);
+
+                    if (!Double.IsInfinity(_maxSize.Width) && _maxSize.Width > 0)
+                        mmi.ptMaxTrackSize.X =
+                            (int)((_maxSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right);
+
+                    if (!Double.IsInfinity(_maxSize.Height) && _maxSize.Height > 0)
+                        mmi.ptMaxTrackSize.Y =
+                            (int)((_maxSize.Height * Scaling) + BorderThickness.Top + BorderThickness.Bottom);
+
+                    Marshal.StructureToPtr(mmi, lParam, true);
+                    return IntPtr.Zero;
+
+                case WindowsMessage.WM_DISPLAYCHANGE:
+                    (Screen as ScreenImpl)?.InvalidateScreensCache();
+                    return IntPtr.Zero;
+            }
+
+#if USE_MANAGED_DRAG
+            if (_managedDrag.PreprocessInputEvent(ref e))
+                return UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam);
+#endif
+
+            if (e != null && Input != null)
+            {
+                Input(e);
+
+                if (e.Handled)
+                {
+                    return IntPtr.Zero;
+                }
+            }
+
+            using (_rendererLock.Lock())
+                return DefWindowProc(hWnd, msg, wParam, lParam);
+        }
+
+        private static int ToInt32(IntPtr ptr)
+        {
+            if (IntPtr.Size == 4)
+                return ptr.ToInt32();
+
+            return (int)(ptr.ToInt64() & 0xffffffff);
+        }
+
+        private static int HighWord(int param) => param >> 16;
+
+        private Point DipFromLParam(IntPtr lParam)
+        {
+            return new Point((short)(ToInt32(lParam) & 0xffff), (short)(ToInt32(lParam) >> 16)) / Scaling;
+        }
+
+        private PixelPoint PointFromLParam(IntPtr lParam)
+        {
+            return new PixelPoint((short)(ToInt32(lParam) & 0xffff), (short)(ToInt32(lParam) >> 16));
+        }
+
+        private bool ShouldIgnoreTouchEmulatedMessage()
+        {
+            if (!_multitouch)
+                return false;
+            var marker = 0xFF515700L;
+            var info = GetMessageExtraInfo().ToInt64();
+            return (info & marker) == marker;
+        }
+
+        private static RawInputModifiers GetMouseModifiers(IntPtr wParam)
+        {
+            var keys = (ModifierKeys)ToInt32(wParam);
+            var modifiers = WindowsKeyboardDevice.Instance.Modifiers;
+            if (keys.HasFlagCustom(ModifierKeys.MK_LBUTTON))
+                modifiers |= RawInputModifiers.LeftMouseButton;
+            if (keys.HasFlagCustom(ModifierKeys.MK_RBUTTON))
+                modifiers |= RawInputModifiers.RightMouseButton;
+            if (keys.HasFlagCustom(ModifierKeys.MK_MBUTTON))
+                modifiers |= RawInputModifiers.MiddleMouseButton;
+            if (keys.HasFlagCustom(ModifierKeys.MK_XBUTTON1))
+                modifiers |= RawInputModifiers.XButton1MouseButton;
+            if (keys.HasFlagCustom(ModifierKeys.MK_XBUTTON2))
+                modifiers |= RawInputModifiers.XButton2MouseButton;
+            return modifiers;
+        }
+    }
+}
diff --git a/src/Windows/Avalonia.Win32/WindowImpl.cs b/src/Windows/Avalonia.Win32/WindowImpl.cs
index 6900d73c93..f82bea0d49 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.cs
@@ -4,7 +4,6 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
 using Avalonia.Controls;
 using Avalonia.Input;
@@ -18,43 +17,62 @@ using static Avalonia.Win32.Interop.UnmanagedMethods;
 
 namespace Avalonia.Win32
 {
-    public class WindowImpl : IWindowImpl, EglGlPlatformSurface.IEglWindowGlPlatformSurfaceInfo
+    /// <summary>
+    /// Window implementation for Win32 platform.
+    /// </summary>
+    public partial class WindowImpl : IWindowImpl, EglGlPlatformSurface.IEglWindowGlPlatformSurfaceInfo
     {
         private static readonly List<WindowImpl> s_instances = new List<WindowImpl>();
 
-        private static readonly IntPtr DefaultCursor = UnmanagedMethods.LoadCursor(
+        private static readonly IntPtr DefaultCursor = LoadCursor(
             IntPtr.Zero, new IntPtr((int)UnmanagedMethods.Cursor.IDC_ARROW));
 
-        private UnmanagedMethods.WndProc _wndProcDelegate;
+        private static readonly Dictionary<WindowEdge, HitTestValues> s_edgeLookup =
+            new Dictionary<WindowEdge, HitTestValues>
+            {
+                { WindowEdge.East, HitTestValues.HTRIGHT },
+                { WindowEdge.North, HitTestValues.HTTOP },
+                { WindowEdge.NorthEast, HitTestValues.HTTOPRIGHT },
+                { WindowEdge.NorthWest, HitTestValues.HTTOPLEFT },
+                { WindowEdge.South, HitTestValues.HTBOTTOM },
+                { WindowEdge.SouthEast, HitTestValues.HTBOTTOMRIGHT },
+                { WindowEdge.SouthWest, HitTestValues.HTBOTTOMLEFT },
+                { WindowEdge.West, HitTestValues.HTLEFT }
+            };
+
+#if USE_MANAGED_DRAG
+        private readonly ManagedWindowResizeDragHelper _managedDrag;
+#endif
+
+        private readonly List<WindowImpl> _disabledBy;
+        private readonly TouchDevice _touchDevice;
+        private readonly MouseDevice _mouseDevice;
+        private readonly ManagedDeferredRendererLock _rendererLock;
+        private readonly FramebufferManager _framebuffer;
+        private readonly IGlPlatformSurface _gl;
+
+        private WndProc _wndProcDelegate;
         private string _className;
         private IntPtr _hwnd;
         private bool _multitouch;
-        private TouchDevice _touchDevice = new TouchDevice();
-        private MouseDevice _mouseDevice = new WindowsMouseDevice();
         private IInputRoot _owner;
-        private ManagedDeferredRendererLock _rendererLock = new ManagedDeferredRendererLock();
+        private WindowProperties _windowProperties;
         private bool _trackingMouse;
-        private SystemDecorations _decorated = SystemDecorations.Full;
-        private bool _resizable = true;
-        private bool _topmost = false;
-        private bool _taskbarIcon = true;
+        private bool _topmost;
         private double _scaling = 1;
         private WindowState _showWindowState;
         private WindowState _lastWindowState;
-        private FramebufferManager _framebuffer;
-        private IGlPlatformSurface _gl;
         private OleDropTarget _dropTarget;
         private Size _minSize;
         private Size _maxSize;
         private WindowImpl _parent;
-        private readonly List<WindowImpl> _disabledBy = new List<WindowImpl>();
-
-#if USE_MANAGED_DRAG
-        private readonly ManagedWindowResizeDragHelper _managedDrag;
-#endif
 
         public WindowImpl()
         {
+            _disabledBy = new List<WindowImpl>();
+            _touchDevice = new TouchDevice();
+            _mouseDevice = new WindowsMouseDevice();
+
 #if USE_MANAGED_DRAG
             _managedDrag = new ManagedWindowResizeDragHelper(this, capture =>
             {
@@ -64,11 +82,24 @@ namespace Avalonia.Win32
                     UnmanagedMethods.ReleaseCapture();
             });
 #endif
+
+            _windowProperties = new WindowProperties
+            {
+                ShowInTaskbar = false, IsResizable = true, Decorations = SystemDecorations.Full
+            };
+            _rendererLock = new ManagedDeferredRendererLock();
+
+
             CreateWindow();
             _framebuffer = new FramebufferManager(_hwnd);
+
             if (Win32GlManager.EglFeature != null)
+            {
                 _gl = new EglGlPlatformSurface((EglDisplay)Win32GlManager.EglFeature.Display,
                     Win32GlManager.EglFeature.DeferredContext, this);
+            }
+
+            Screen = new ScreenImpl();
 
             s_instances.Add(this);
         }
@@ -97,14 +128,14 @@ namespace Avalonia.Win32
         {
             get
             {
-                if (_decorated == SystemDecorations.Full)
+                if (HasFullDecorations)
                 {
-                    var style = UnmanagedMethods.GetWindowLong(_hwnd, (int)UnmanagedMethods.WindowLongParam.GWL_STYLE);
-                    var exStyle = UnmanagedMethods.GetWindowLong(_hwnd, (int)UnmanagedMethods.WindowLongParam.GWL_EXSTYLE);
+                    var style = GetStyle();
+                    var exStyle = GetExtendedStyle();
 
                     var padding = new RECT();
 
-                    if (UnmanagedMethods.AdjustWindowRectEx(ref padding, style, false, exStyle))
+                    if (AdjustWindowRectEx(ref padding, (uint)style, false, (uint)exStyle))
                     {
                         return new Thickness(-padding.left, -padding.top, padding.right, padding.bottom);
                     }
@@ -120,68 +151,19 @@ namespace Avalonia.Win32
             }
         }
 
+        public double Scaling => _scaling;
+
         public Size ClientSize
         {
             get
             {
-                UnmanagedMethods.RECT rect;
-                UnmanagedMethods.GetClientRect(_hwnd, out rect);
-                return new Size(rect.right, rect.bottom) / Scaling;
-            }
-        }
-
-        public void Move(PixelPoint point) => Position = point;
-
-        public void SetMinMaxSize(Size minSize, Size maxSize)
-        {
-            _minSize = minSize;
-            _maxSize = maxSize;
-        }
-
-        public IScreenImpl Screen
-        {
-            get;
-        } = new ScreenImpl();
-
-
-        public IRenderer CreateRenderer(IRenderRoot root)
-        {
-            var loop = AvaloniaLocator.Current.GetService<IRenderLoop>();
-            var customRendererFactory = AvaloniaLocator.Current.GetService<IRendererFactory>();
-
-            if (customRendererFactory != null)
-                return customRendererFactory.Create(root, loop);
-
-            return Win32Platform.UseDeferredRendering ?
-                (IRenderer)new DeferredRenderer(root, loop, rendererLock: _rendererLock) :
-                new ImmediateRenderer(root);
-        }
-
-        public void Resize(Size value)
-        {
-            int requestedClientWidth = (int)(value.Width * Scaling);
-            int requestedClientHeight = (int)(value.Height * Scaling);
-            UnmanagedMethods.RECT clientRect;
-            UnmanagedMethods.GetClientRect(_hwnd, out clientRect);
-           
-            // do comparison after scaling to avoid rounding issues
-            if (requestedClientWidth != clientRect.Width || requestedClientHeight != clientRect.Height)
-            {
-                UnmanagedMethods.RECT windowRect;
-                UnmanagedMethods.GetWindowRect(_hwnd, out windowRect);
+                GetClientRect(_hwnd, out var rect);
 
-                UnmanagedMethods.SetWindowPos(
-                    _hwnd,
-                    IntPtr.Zero,
-                    0,
-                    0,
-                    requestedClientWidth + (windowRect.Width - clientRect.Width),
-                    requestedClientHeight + (windowRect.Height - clientRect.Height),
-                    UnmanagedMethods.SetWindowPosFlags.SWP_RESIZE);
+                return new Size(rect.right, rect.bottom) / Scaling;
             }
         }
 
-        public double Scaling => _scaling;
+        public IScreenImpl Screen { get; }
 
         public IPlatformHandle Handle
         {
@@ -189,20 +171,14 @@ namespace Avalonia.Win32
             private set;
         }
 
-
-        void UpdateEnabled()
-        {
-            EnableWindow(_hwnd, _disabledBy.Count == 0);
-        }
-
         public Size MaxClientSize
         {
             get
             {
                 return (new Size(
-                    UnmanagedMethods.GetSystemMetrics(UnmanagedMethods.SystemMetric.SM_CXMAXTRACK),
-                    UnmanagedMethods.GetSystemMetrics(UnmanagedMethods.SystemMetric.SM_CYMAXTRACK))
-                    - BorderThickness) / Scaling;
+                            GetSystemMetrics(SystemMetric.SM_CXMAXTRACK),
+                            GetSystemMetrics(SystemMetric.SM_CYMAXTRACK))
+                        - BorderThickness) / Scaling;
             }
         }
 
@@ -212,14 +188,14 @@ namespace Avalonia.Win32
         {
             get
             {
-                var placement = default(UnmanagedMethods.WINDOWPLACEMENT);
-                UnmanagedMethods.GetWindowPlacement(_hwnd, ref placement);
+                var placement = default(WINDOWPLACEMENT);
+                GetWindowPlacement(_hwnd, ref placement);
 
                 switch (placement.ShowCmd)
                 {
-                    case UnmanagedMethods.ShowWindowCommand.Maximize:
+                    case ShowWindowCommand.Maximize:
                         return WindowState.Maximized;
-                    case UnmanagedMethods.ShowWindowCommand.Minimize:
+                    case ShowWindowCommand.Minimize:
                         return WindowState.Minimized;
                     default:
                         return WindowState.Normal;
@@ -228,7 +204,7 @@ namespace Avalonia.Win32
 
             set
             {
-                if (UnmanagedMethods.IsWindowVisible(_hwnd))
+                if (IsWindowVisible(_hwnd))
                 {
                     ShowWindow(value);
                 }
@@ -239,14 +215,78 @@ namespace Avalonia.Win32
             }
         }
 
-        public IEnumerable<object> Surfaces => new object[]
+        public IEnumerable<object> Surfaces => new object[] { Handle, _gl, _framebuffer };
+
+        public PixelPoint Position
+        {
+            get
+            {
+                GetWindowRect(_hwnd, out var rc);
+
+                return new PixelPoint(rc.left, rc.top);
+            }
+            set
+            {
+                SetWindowPos(
+                    Handle.Handle,
+                    IntPtr.Zero,
+                    value.X,
+                    value.Y,
+                    0,
+                    0,
+                    SetWindowPosFlags.SWP_NOSIZE | SetWindowPosFlags.SWP_NOACTIVATE);
+            }
+        }
+
+        private bool HasFullDecorations => _windowProperties.Decorations == SystemDecorations.Full;
+
+        public void Move(PixelPoint point) => Position = point;
+
+        public void SetMinMaxSize(Size minSize, Size maxSize)
+        {
+            _minSize = minSize;
+            _maxSize = maxSize;
+        }
+
+        public IRenderer CreateRenderer(IRenderRoot root)
         {
-            Handle, _gl, _framebuffer
-        };
+            var loop = AvaloniaLocator.Current.GetService<IRenderLoop>();
+            var customRendererFactory = AvaloniaLocator.Current.GetService<IRendererFactory>();
+
+            if (customRendererFactory != null)
+                return customRendererFactory.Create(root, loop);
+
+            return Win32Platform.UseDeferredRendering ?
+                (IRenderer)new DeferredRenderer(root, loop, rendererLock: _rendererLock) :
+                new ImmediateRenderer(root);
+        }
+
+        public void Resize(Size value)
+        {
+            int requestedClientWidth = (int)(value.Width * Scaling);
+            int requestedClientHeight = (int)(value.Height * Scaling);
+
+            GetClientRect(_hwnd, out var clientRect);
+
+            // do comparison after scaling to avoid rounding issues
+            if (requestedClientWidth != clientRect.Width || requestedClientHeight != clientRect.Height)
+            {
+                GetWindowRect(_hwnd, out var windowRect);
+
+                SetWindowPos(
+                    _hwnd,
+                    IntPtr.Zero,
+                    0,
+                    0,
+                    requestedClientWidth + (windowRect.Width - clientRect.Width),
+                    requestedClientHeight + (windowRect.Height - clientRect.Height),
+                    SetWindowPosFlags.SWP_RESIZE);
+            }
+        }
 
         public void Activate()
         {
-            UnmanagedMethods.SetActiveWindow(_hwnd);
+            SetActiveWindow(_hwnd);
         }
 
         public IPopupImpl CreatePopup() => Win32Platform.UseOverlayPopups ? null : new PopupImpl(this);
@@ -258,56 +298,46 @@ namespace Avalonia.Win32
                 OleContext.Current?.UnregisterDragDrop(Handle);
                 _dropTarget = null;
             }
+
             if (_hwnd != IntPtr.Zero)
             {
-                UnmanagedMethods.DestroyWindow(_hwnd);
+                DestroyWindow(_hwnd);
                 _hwnd = IntPtr.Zero;
             }
+
             if (_className != null)
             {
-                UnmanagedMethods.UnregisterClass(_className, UnmanagedMethods.GetModuleHandle(null));
+                UnregisterClass(_className, GetModuleHandle(null));
                 _className = null;
             }
         }
 
-        public void Hide()
-        {
-            if (_parent != null)
-            {
-                _parent._disabledBy.Remove(this);
-                _parent.UpdateEnabled();
-                _parent = null;
-            }
-            UnmanagedMethods.ShowWindow(_hwnd, UnmanagedMethods.ShowWindowCommand.Hide);
-        }
-
         public void SetSystemDecorations(SystemDecorations value)
         {
-            if (value == _decorated)
-            {
-                return;
-            }
+            var newWindowProperties = _windowProperties;
+
+            newWindowProperties.Decorations = value;
 
-            UpdateWMStyles(()=> _decorated = value);
+            UpdateWindowProperties(newWindowProperties);
         }
 
         public void Invalidate(Rect rect)
         {
-            var f = Scaling;
-            var r = new UnmanagedMethods.RECT
+            var scaling = Scaling;
+            var r = new RECT
             {
-                left = (int)Math.Floor(rect.X * f),
-                top = (int)Math.Floor(rect.Y * f),
-                right = (int)Math.Ceiling(rect.Right * f),
-                bottom = (int)Math.Ceiling(rect.Bottom * f),
+                left = (int)Math.Floor(rect.X * scaling),
+                top = (int)Math.Floor(rect.Y * scaling),
+                right = (int)Math.Ceiling(rect.Right * scaling),
+                bottom = (int)Math.Ceiling(rect.Bottom * scaling),
             };
 
-            UnmanagedMethods.InvalidateRect(_hwnd, ref r, false);
+            InvalidateRect(_hwnd, ref r, false);
         }
 
         public Point PointToClient(PixelPoint point)
         {
-            var p = new UnmanagedMethods.POINT { X = (int)point.X, Y = (int)point.Y };
+            var p = new POINT { X = point.X, Y = point.Y };
             UnmanagedMethods.ScreenToClient(_hwnd, ref p);
             return new Point(p.X, p.Y) / Scaling;
         }
@@ -315,8 +345,8 @@ namespace Avalonia.Win32
         public PixelPoint PointToScreen(Point point)
         {
             point *= Scaling;
-            var p = new UnmanagedMethods.POINT { X = (int)point.X, Y = (int)point.Y };
-            UnmanagedMethods.ClientToScreen(_hwnd, ref p);
+            var p = new POINT { X = (int)point.X, Y = (int)point.Y };
+            ClientToScreen(_hwnd, ref p);
             return new PixelPoint(p.X, p.Y);
         }
 
@@ -328,7 +358,19 @@ namespace Avalonia.Win32
 
         public void SetTitle(string title)
         {
-            UnmanagedMethods.SetWindowText(_hwnd, title);
+            SetWindowText(_hwnd, title);
+        }
+
+        public void Hide()
+        {
+            if (_parent != null)
+            {
+                _parent._disabledBy.Remove(this);
+                _parent.UpdateEnabled();
+                _parent = null;
+            }
+
+            UnmanagedMethods.ShowWindow(_hwnd, ShowWindowCommand.Hide);
         }
 
         public virtual void Show()
@@ -337,72 +379,38 @@ namespace Avalonia.Win32
             ShowWindow(_showWindowState);
         }
 
+        public void ShowDialog(IWindowImpl parent)
+        {
+            _parent = (WindowImpl)parent;
+            _parent._disabledBy.Add(this);
+            _parent.UpdateEnabled();
+            SetWindowLongPtr(_hwnd, (int)WindowLongParam.GWL_HWNDPARENT, ((WindowImpl)parent)._hwnd);
+            ShowWindow(_showWindowState);
+        }
+
         public void BeginMoveDrag(PointerPressedEventArgs e)
         {
             _mouseDevice.Capture(null);
-            UnmanagedMethods.DefWindowProc(_hwnd, (int)UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN,
-                new IntPtr((int)UnmanagedMethods.HitTestValues.HTCAPTION), IntPtr.Zero);
+            DefWindowProc(_hwnd, (int)WindowsMessage.WM_NCLBUTTONDOWN,
+                new IntPtr((int)HitTestValues.HTCAPTION), IntPtr.Zero);
             e.Pointer.Capture(null);
         }
 
-        static readonly Dictionary<WindowEdge, UnmanagedMethods.HitTestValues> EdgeDic = new Dictionary<WindowEdge, UnmanagedMethods.HitTestValues>
-        {
-            {WindowEdge.East, UnmanagedMethods.HitTestValues.HTRIGHT},
-            {WindowEdge.North, UnmanagedMethods.HitTestValues.HTTOP },
-            {WindowEdge.NorthEast, UnmanagedMethods.HitTestValues.HTTOPRIGHT },
-            {WindowEdge.NorthWest, UnmanagedMethods.HitTestValues.HTTOPLEFT },
-            {WindowEdge.South, UnmanagedMethods.HitTestValues.HTBOTTOM },
-            {WindowEdge.SouthEast, UnmanagedMethods.HitTestValues.HTBOTTOMRIGHT },
-            {WindowEdge.SouthWest, UnmanagedMethods.HitTestValues.HTBOTTOMLEFT },
-            {WindowEdge.West, UnmanagedMethods.HitTestValues.HTLEFT}
-        };
-
         public void BeginResizeDrag(WindowEdge edge, PointerPressedEventArgs e)
         {
 #if USE_MANAGED_DRAG
             _managedDrag.BeginResizeDrag(edge, ScreenToClient(MouseDevice.Position));
 #else
             _mouseDevice.Capture(null);
-            UnmanagedMethods.DefWindowProc(_hwnd, (int)UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN,
-                new IntPtr((int)EdgeDic[edge]), IntPtr.Zero);
+            DefWindowProc(_hwnd, (int)WindowsMessage.WM_NCLBUTTONDOWN,
+                new IntPtr((int)s_edgeLookup[edge]), IntPtr.Zero);
 #endif
         }
 
-        public PixelPoint Position
-        {
-            get
-            {
-                UnmanagedMethods.RECT rc;
-                UnmanagedMethods.GetWindowRect(_hwnd, out rc);
-                return new PixelPoint(rc.left, rc.top);
-            }
-            set
-            {
-                UnmanagedMethods.SetWindowPos(
-                    Handle.Handle,
-                    IntPtr.Zero,
-                    value.X,
-                    value.Y,
-                    0,
-                    0,
-                    UnmanagedMethods.SetWindowPosFlags.SWP_NOSIZE | UnmanagedMethods.SetWindowPosFlags.SWP_NOACTIVATE);
-
-            }
-        }
-
-        public void ShowDialog(IWindowImpl parent)
-        {
-            _parent = (WindowImpl)parent;
-            _parent._disabledBy.Add(this);
-            _parent.UpdateEnabled();
-            SetWindowLongPtr(_hwnd, (int)WindowLongParam.GWL_HWNDPARENT, ((WindowImpl)parent)._hwnd);
-            ShowWindow(_showWindowState);
-        }
-
         public void SetCursor(IPlatformHandle cursor)
         {
             var hCursor = cursor?.Handle ?? DefaultCursor;
-            UnmanagedMethods.SetClassLong(_hwnd, UnmanagedMethods.ClassLongIndex.GCLP_HCURSOR, hCursor);
+            SetClassLong(_hwnd, ClassLongIndex.GCLP_HCURSOR, hCursor);
 
             if (_owner.IsPointerOver)
                 UnmanagedMethods.SetCursor(hCursor);
@@ -410,417 +418,84 @@ namespace Avalonia.Win32
 
         protected virtual IntPtr CreateWindowOverride(ushort atom)
         {
-            return UnmanagedMethods.CreateWindowEx(
+            return CreateWindowEx(
                 0,
                 atom,
                 null,
-                (int)UnmanagedMethods.WindowStyles.WS_OVERLAPPEDWINDOW,
-                UnmanagedMethods.CW_USEDEFAULT,
-                UnmanagedMethods.CW_USEDEFAULT,
-                UnmanagedMethods.CW_USEDEFAULT,
-                UnmanagedMethods.CW_USEDEFAULT,
+                (int)WindowStyles.WS_OVERLAPPEDWINDOW,
+                CW_USEDEFAULT,
+                CW_USEDEFAULT,
+                CW_USEDEFAULT,
+                CW_USEDEFAULT,
                 IntPtr.Zero,
                 IntPtr.Zero,
                 IntPtr.Zero,
                 IntPtr.Zero);
         }
 
-        bool ShouldIgnoreTouchEmulatedMessage()
+        public void SetIcon(IWindowIconImpl icon)
         {
-            if (!_multitouch)
-                return false;
-            var marker = 0xFF515700L;
-            var info = GetMessageExtraInfo().ToInt64();
-            return (info & marker) == marker;
+            var impl = (IconImpl)icon;
+            var hIcon = impl?.HIcon ?? IntPtr.Zero;
+            PostMessage(_hwnd, (int)WindowsMessage.WM_SETICON,
+                new IntPtr((int)Icons.ICON_BIG), hIcon);
         }
-        
-        [SuppressMessage("Microsoft.StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Justification = "Using Win32 naming for consistency.")]
-        protected virtual unsafe IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
-        {
-            bool unicode = UnmanagedMethods.IsWindowUnicode(hWnd);
-
-            const double wheelDelta = 120.0;
-            uint timestamp = unchecked((uint)UnmanagedMethods.GetMessageTime());
-
-            RawInputEventArgs e = null;
-            
-            switch ((UnmanagedMethods.WindowsMessage)msg)
-            {
-                case UnmanagedMethods.WindowsMessage.WM_ACTIVATE:
-                    var wa = (UnmanagedMethods.WindowActivate)(ToInt32(wParam) & 0xffff);
-
-                    switch (wa)
-                    {
-                        case UnmanagedMethods.WindowActivate.WA_ACTIVE:
-                        case UnmanagedMethods.WindowActivate.WA_CLICKACTIVE:
-                            Activated?.Invoke();
-                            break;
-
-                        case UnmanagedMethods.WindowActivate.WA_INACTIVE:
-                            Deactivated?.Invoke();
-                            break;
-                    }
-
-                    return IntPtr.Zero;
-
-                case WindowsMessage.WM_NCCALCSIZE:
-                    if (ToInt32(wParam) == 1 && _decorated != SystemDecorations.Full)
-                    {
-                        return IntPtr.Zero;
-                    }
-                    break;
-
-                case UnmanagedMethods.WindowsMessage.WM_CLOSE:
-                    bool? preventClosing = Closing?.Invoke();
-                    if (preventClosing == true)
-                    {
-                        return IntPtr.Zero;
-                    }
-                    break;
-
-                case UnmanagedMethods.WindowsMessage.WM_DESTROY:
-                    //Window doesn't exist anymore
-                    _hwnd = IntPtr.Zero;
-                    //Remove root reference to this class, so unmanaged delegate can be collected
-                    s_instances.Remove(this);
-                    Closed?.Invoke();
-                    if (_parent != null)
-                    {
-                        _parent._disabledBy.Remove(this);
-                        _parent.UpdateEnabled();
-                    }
-                    _mouseDevice.Dispose();
-                    _touchDevice?.Dispose();
-                    //Free other resources
-                    Dispose();
-                    return IntPtr.Zero;
-
-                case UnmanagedMethods.WindowsMessage.WM_DPICHANGED:
-                    var dpi = ToInt32(wParam) & 0xffff;
-                    var newDisplayRect = Marshal.PtrToStructure<UnmanagedMethods.RECT>(lParam);
-                    _scaling = dpi / 96.0;
-                    ScalingChanged?.Invoke(_scaling);
-                    SetWindowPos(hWnd,
-                        IntPtr.Zero,
-                        newDisplayRect.left,
-                        newDisplayRect.top,
-                        newDisplayRect.right - newDisplayRect.left,
-                        newDisplayRect.bottom - newDisplayRect.top,
-                        SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOACTIVATE);
-                    return IntPtr.Zero;
-
-                case UnmanagedMethods.WindowsMessage.WM_KEYDOWN:
-                case UnmanagedMethods.WindowsMessage.WM_SYSKEYDOWN:
-                    e = new RawKeyEventArgs(
-                            WindowsKeyboardDevice.Instance,
-                            timestamp,
-                            _owner,
-                            RawKeyEventType.KeyDown,
-                            KeyInterop.KeyFromVirtualKey(ToInt32(wParam), ToInt32(lParam)), WindowsKeyboardDevice.Instance.Modifiers);
-                    break;
-
-                case UnmanagedMethods.WindowsMessage.WM_MENUCHAR:
-                    // mute the system beep
-                    return (IntPtr)((Int32)UnmanagedMethods.MenuCharParam.MNC_CLOSE << 16);
-
-                case UnmanagedMethods.WindowsMessage.WM_KEYUP:
-                case UnmanagedMethods.WindowsMessage.WM_SYSKEYUP:
-                    e = new RawKeyEventArgs(
-                            WindowsKeyboardDevice.Instance,
-                            timestamp,
-                            _owner,
-                            RawKeyEventType.KeyUp,
-                            KeyInterop.KeyFromVirtualKey(ToInt32(wParam), ToInt32(lParam)), WindowsKeyboardDevice.Instance.Modifiers);
-                    break;
-                case UnmanagedMethods.WindowsMessage.WM_CHAR:
-                    // Ignore control chars
-                    if (ToInt32(wParam) >= 32)
-                    {
-                        e = new RawTextInputEventArgs(WindowsKeyboardDevice.Instance, timestamp, _owner,
-                            new string((char)ToInt32(wParam), 1));
-                    }
-
-                    break;
-
-                case UnmanagedMethods.WindowsMessage.WM_LBUTTONDOWN:
-                case UnmanagedMethods.WindowsMessage.WM_RBUTTONDOWN:
-                case UnmanagedMethods.WindowsMessage.WM_MBUTTONDOWN:
-                case UnmanagedMethods.WindowsMessage.WM_XBUTTONDOWN:
-                    if (ShouldIgnoreTouchEmulatedMessage())
-                        break;
-                    e = new RawPointerEventArgs(
-                        _mouseDevice,
-                        timestamp,
-                        _owner,
-                        (UnmanagedMethods.WindowsMessage)msg switch
-                        {
-                            UnmanagedMethods.WindowsMessage.WM_LBUTTONDOWN => RawPointerEventType.LeftButtonDown,
-                            UnmanagedMethods.WindowsMessage.WM_RBUTTONDOWN => RawPointerEventType.RightButtonDown,
-                            UnmanagedMethods.WindowsMessage.WM_MBUTTONDOWN => RawPointerEventType.MiddleButtonDown,
-                            UnmanagedMethods.WindowsMessage.WM_XBUTTONDOWN =>
-                                HighWord(ToInt32(wParam)) == 1 ? RawPointerEventType.XButton1Down : RawPointerEventType.XButton2Down
-                        },
-                        DipFromLParam(lParam), GetMouseModifiers(wParam));
-                    break;
-
-                case UnmanagedMethods.WindowsMessage.WM_LBUTTONUP:
-                case UnmanagedMethods.WindowsMessage.WM_RBUTTONUP:
-                case UnmanagedMethods.WindowsMessage.WM_MBUTTONUP:
-                case UnmanagedMethods.WindowsMessage.WM_XBUTTONUP:
-                    if (ShouldIgnoreTouchEmulatedMessage())
-                        break;
-                    e = new RawPointerEventArgs(
-                        _mouseDevice,
-                        timestamp,
-                        _owner,
-                        (UnmanagedMethods.WindowsMessage)msg switch
-                        {
-                            UnmanagedMethods.WindowsMessage.WM_LBUTTONUP => RawPointerEventType.LeftButtonUp,
-                            UnmanagedMethods.WindowsMessage.WM_RBUTTONUP => RawPointerEventType.RightButtonUp,
-                            UnmanagedMethods.WindowsMessage.WM_MBUTTONUP => RawPointerEventType.MiddleButtonUp,
-                            UnmanagedMethods.WindowsMessage.WM_XBUTTONUP =>
-                                HighWord(ToInt32(wParam)) == 1 ? RawPointerEventType.XButton1Up : RawPointerEventType.XButton2Up,
-                        },
-                        DipFromLParam(lParam), GetMouseModifiers(wParam));
-                    break;
-
-                case UnmanagedMethods.WindowsMessage.WM_MOUSEMOVE:
-                    if(ShouldIgnoreTouchEmulatedMessage())
-                        break;
-                    if (!_trackingMouse)
-                    {
-                        var tm = new UnmanagedMethods.TRACKMOUSEEVENT
-                        {
-                            cbSize = Marshal.SizeOf<UnmanagedMethods.TRACKMOUSEEVENT>(),
-                            dwFlags = 2,
-                            hwndTrack = _hwnd,
-                            dwHoverTime = 0,
-                        };
-
-                        UnmanagedMethods.TrackMouseEvent(ref tm);
-                    }
-
-                    e = new RawPointerEventArgs(
-                        _mouseDevice,
-                        timestamp,
-                        _owner,
-                        RawPointerEventType.Move,
-                        DipFromLParam(lParam), GetMouseModifiers(wParam));
-
-                    break;
-
-                case UnmanagedMethods.WindowsMessage.WM_MOUSEWHEEL:
-                    e = new RawMouseWheelEventArgs(
-                        _mouseDevice,
-                        timestamp,
-                        _owner,
-                        PointToClient(PointFromLParam(lParam)),
-                        new Vector(0, (ToInt32(wParam) >> 16) / wheelDelta), GetMouseModifiers(wParam));
-                    break;
-
-                case UnmanagedMethods.WindowsMessage.WM_MOUSEHWHEEL:
-                    e = new RawMouseWheelEventArgs(
-                        _mouseDevice,
-                        timestamp,
-                        _owner,
-                        PointToClient(PointFromLParam(lParam)),
-                        new Vector(-(ToInt32(wParam) >> 16) / wheelDelta, 0), GetMouseModifiers(wParam));
-                    break;
-
-                case UnmanagedMethods.WindowsMessage.WM_MOUSELEAVE:
-                    _trackingMouse = false;
-                    e = new RawPointerEventArgs(
-                        _mouseDevice,
-                        timestamp,
-                        _owner,
-                        RawPointerEventType.LeaveWindow,
-                        new Point(-1,-1), WindowsKeyboardDevice.Instance.Modifiers);
-                    break;
-
-                case UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN:
-                case UnmanagedMethods.WindowsMessage.WM_NCRBUTTONDOWN:
-                case UnmanagedMethods.WindowsMessage.WM_NCMBUTTONDOWN:
-                case UnmanagedMethods.WindowsMessage.WM_NCXBUTTONDOWN:
-                    e = new RawPointerEventArgs(
-                        _mouseDevice,
-                        timestamp,
-                        _owner,
-                        (UnmanagedMethods.WindowsMessage)msg switch
-                        {
-                            UnmanagedMethods.WindowsMessage.WM_NCLBUTTONDOWN => RawPointerEventType.NonClientLeftButtonDown,
-                            UnmanagedMethods.WindowsMessage.WM_NCRBUTTONDOWN => RawPointerEventType.RightButtonDown,
-                            UnmanagedMethods.WindowsMessage.WM_NCMBUTTONDOWN => RawPointerEventType.MiddleButtonDown,
-                            UnmanagedMethods.WindowsMessage.WM_NCXBUTTONDOWN =>
-                                HighWord(ToInt32(wParam)) == 1 ? RawPointerEventType.XButton1Down : RawPointerEventType.XButton2Down,
-                        },
-                        PointToClient(PointFromLParam(lParam)), GetMouseModifiers(wParam));
-                    break;
-                case WindowsMessage.WM_TOUCH:
-                    var touchInputCount = wParam.ToInt32();
-
-                    var pTouchInputs = stackalloc TOUCHINPUT[touchInputCount];
-                    var touchInputs = new Span<TOUCHINPUT>(pTouchInputs, touchInputCount);
 
-                    if (GetTouchInputInfo(lParam, (uint)touchInputCount, pTouchInputs, Marshal.SizeOf<TOUCHINPUT>()))
-                    {
-                        foreach (var touchInput in touchInputs)
-                        {
-                            Input?.Invoke(new RawTouchEventArgs(_touchDevice, touchInput.Time,
-                                _owner,
-                                touchInput.Flags.HasFlagCustom(TouchInputFlags.TOUCHEVENTF_UP) ?
-                                    RawPointerEventType.TouchEnd :
-                                    touchInput.Flags.HasFlagCustom(TouchInputFlags.TOUCHEVENTF_DOWN) ?
-                                        RawPointerEventType.TouchBegin :
-                                        RawPointerEventType.TouchUpdate,
-                                PointToClient(new PixelPoint(touchInput.X / 100, touchInput.Y / 100)),
-                                WindowsKeyboardDevice.Instance.Modifiers,
-                                touchInput.Id));
-                        }
-                        CloseTouchInputHandle(lParam);
-                        return IntPtr.Zero;
-                    }
-                    
-                    break;
-                case WindowsMessage.WM_NCPAINT:
-                    if (_decorated != SystemDecorations.Full)
-                    {
-                        return IntPtr.Zero;
-                    }
-                    break;
-
-                case WindowsMessage.WM_NCACTIVATE:
-                    if (_decorated != SystemDecorations.Full)
-                    {
-                        return new IntPtr(1);
-                    }
-                    break;
-
-                case UnmanagedMethods.WindowsMessage.WM_PAINT:
-                    using (_rendererLock.Lock())
-                    {
-                        UnmanagedMethods.PAINTSTRUCT ps;
-                        if (UnmanagedMethods.BeginPaint(_hwnd, out ps) != IntPtr.Zero)
-                        {
-                            var f = Scaling;
-                            var r = ps.rcPaint;
-                            Paint?.Invoke(new Rect(r.left / f, r.top / f, (r.right - r.left) / f,
-                                (r.bottom - r.top) / f));
-                            UnmanagedMethods.EndPaint(_hwnd, ref ps);
-                        }
-                    }
-
-                    return IntPtr.Zero;
-
-                case UnmanagedMethods.WindowsMessage.WM_SIZE:
-                    using (_rendererLock.Lock())
-                    {
-                        // Do nothing here, just block until the pending frame render is completed on the render thread
-                    }
-                    var size = (UnmanagedMethods.SizeCommand)wParam;
-
-                    if (Resized != null &&
-                        (size == UnmanagedMethods.SizeCommand.Restored ||
-                         size == UnmanagedMethods.SizeCommand.Maximized))
-                    {
-                        var clientSize = new Size(ToInt32(lParam) & 0xffff, ToInt32(lParam) >> 16);
-                        Resized(clientSize / Scaling);
-                    }
-
-                    var windowState = size == SizeCommand.Maximized ? WindowState.Maximized
-                        : (size == SizeCommand.Minimized ? WindowState.Minimized : WindowState.Normal);
-
-                    if (windowState != _lastWindowState)
-                    {
-                        _lastWindowState = windowState;
-                        WindowStateChanged?.Invoke(windowState);
-                    }
-
-                    return IntPtr.Zero;
-
-                case UnmanagedMethods.WindowsMessage.WM_MOVE:
-                    PositionChanged?.Invoke(new PixelPoint((short)(ToInt32(lParam) & 0xffff), (short)(ToInt32(lParam) >> 16)));
-                    return IntPtr.Zero;
-
-                case UnmanagedMethods.WindowsMessage.WM_GETMINMAXINFO:
-
-                    MINMAXINFO mmi = Marshal.PtrToStructure<UnmanagedMethods.MINMAXINFO>(lParam);
-
-                    if (_minSize.Width > 0)
-                        mmi.ptMinTrackSize.X = (int)((_minSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right);
-
-                    if (_minSize.Height > 0)
-                        mmi.ptMinTrackSize.Y = (int)((_minSize.Height * Scaling) + BorderThickness.Top + BorderThickness.Bottom);
-
-                    if (!Double.IsInfinity(_maxSize.Width) && _maxSize.Width > 0)
-                        mmi.ptMaxTrackSize.X = (int)((_maxSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right);
+        public void ShowTaskbarIcon(bool value)
+        {
+            var newWindowProperties = _windowProperties;
 
-                    if (!Double.IsInfinity(_maxSize.Height) && _maxSize.Height > 0)
-                        mmi.ptMaxTrackSize.Y = (int)((_maxSize.Height * Scaling) + BorderThickness.Top + BorderThickness.Bottom);
+            newWindowProperties.ShowInTaskbar = value;
 
-                    Marshal.StructureToPtr(mmi, lParam, true);
-                    return IntPtr.Zero;
+            UpdateWindowProperties(newWindowProperties);
+        }
 
-                case UnmanagedMethods.WindowsMessage.WM_DISPLAYCHANGE:
-                    (Screen as ScreenImpl)?.InvalidateScreensCache();
-                    return IntPtr.Zero;
-            }
+        public void CanResize(bool value)
+        {
+            var newWindowProperties = _windowProperties;
 
-#if USE_MANAGED_DRAG
+            newWindowProperties.IsResizable = value;
 
-            if (_managedDrag.PreprocessInputEvent(ref e))
-                return UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam);
-#endif
+            UpdateWindowProperties(newWindowProperties);
+        }
 
-            if (e != null && Input != null)
+        public void SetTopmost(bool value)
+        {
+            if (value == _topmost)
             {
-                Input(e);
-
-                if (e.Handled)
-                {
-                    return IntPtr.Zero;
-                }
+                return;
             }
 
-            using (_rendererLock.Lock())
-                return UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam);
-        }
+            IntPtr hWndInsertAfter = value ? WindowPosZOrder.HWND_TOPMOST : WindowPosZOrder.HWND_NOTOPMOST;
+            SetWindowPos(_hwnd,
+                hWndInsertAfter,
+                0, 0, 0, 0,
+                SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE | SetWindowPosFlags.SWP_NOACTIVATE);
 
-        static RawInputModifiers GetMouseModifiers(IntPtr wParam)
-        {
-            var keys = (UnmanagedMethods.ModifierKeys)ToInt32(wParam);
-            var modifiers = WindowsKeyboardDevice.Instance.Modifiers;
-            if (keys.HasFlagCustom(UnmanagedMethods.ModifierKeys.MK_LBUTTON))
-                modifiers |= RawInputModifiers.LeftMouseButton;
-            if (keys.HasFlagCustom(UnmanagedMethods.ModifierKeys.MK_RBUTTON))
-                modifiers |= RawInputModifiers.RightMouseButton;
-            if (keys.HasFlagCustom(UnmanagedMethods.ModifierKeys.MK_MBUTTON))
-                modifiers |= RawInputModifiers.MiddleMouseButton;
-            if (keys.HasFlagCustom(UnmanagedMethods.ModifierKeys.MK_XBUTTON1))
-                modifiers |= RawInputModifiers.XButton1MouseButton;
-            if (keys.HasFlagCustom(UnmanagedMethods.ModifierKeys.MK_XBUTTON2))
-                modifiers |= RawInputModifiers.XButton2MouseButton;
-            return modifiers;
+            _topmost = value;
         }
 
         private void CreateWindow()
         {
             // Ensure that the delegate doesn't get garbage collected by storing it as a field.
-            _wndProcDelegate = new UnmanagedMethods.WndProc(WndProc);
+            _wndProcDelegate = WndProc;
 
             _className = $"Avalonia-{Guid.NewGuid().ToString()}";
 
-            UnmanagedMethods.WNDCLASSEX wndClassEx = new UnmanagedMethods.WNDCLASSEX
+            var wndClassEx = new WNDCLASSEX
             {
-                cbSize = Marshal.SizeOf<UnmanagedMethods.WNDCLASSEX>(),
-                style = (int)(ClassStyles.CS_OWNDC | ClassStyles.CS_HREDRAW | ClassStyles.CS_VREDRAW), // Unique DC helps with performance when using Gpu based rendering
+                cbSize = Marshal.SizeOf<WNDCLASSEX>(),
+                style =
+                    (int)(ClassStyles.CS_OWNDC | ClassStyles.CS_HREDRAW |
+                          ClassStyles.CS_VREDRAW), // Unique DC helps with performance when using Gpu based rendering
                 lpfnWndProc = _wndProcDelegate,
-                hInstance = UnmanagedMethods.GetModuleHandle(null),
+                hInstance = GetModuleHandle(null),
                 hCursor = DefaultCursor,
                 hbrBackground = IntPtr.Zero,
                 lpszClassName = _className
             };
 
-            ushort atom = UnmanagedMethods.RegisterClassEx(ref wndClassEx);
+            ushort atom = RegisterClassEx(ref wndClassEx);
 
             if (atom == 0)
             {
@@ -837,22 +512,23 @@ namespace Avalonia.Win32
             Handle = new PlatformHandle(_hwnd, PlatformConstants.WindowHandleType);
 
             _multitouch = Win32Platform.Options.EnableMultitouch ?? false;
+
             if (_multitouch)
-                RegisterTouchWindow(_hwnd, 0);
-            
-            if (UnmanagedMethods.ShCoreAvailable)
             {
-                uint dpix, dpiy;
+                RegisterTouchWindow(_hwnd, 0);
+            }
 
-                var monitor = UnmanagedMethods.MonitorFromWindow(
+            if (ShCoreAvailable)
+            {
+                var monitor = MonitorFromWindow(
                     _hwnd,
-                    UnmanagedMethods.MONITOR.MONITOR_DEFAULTTONEAREST);
+                    MONITOR.MONITOR_DEFAULTTONEAREST);
 
-                if (UnmanagedMethods.GetDpiForMonitor(
-                        monitor,
-                        UnmanagedMethods.MONITOR_DPI_TYPE.MDT_EFFECTIVE_DPI,
-                        out dpix,
-                        out dpiy) == 0)
+                if (GetDpiForMonitor(
+                    monitor,
+                    MONITOR_DPI_TYPE.MDT_EFFECTIVE_DPI,
+                    out var dpix,
+                    out var dpiy) == 0)
                 {
                     _scaling = dpix / 96.0;
                 }
@@ -861,31 +537,17 @@ namespace Avalonia.Win32
 
         private void CreateDropTarget()
         {
-            OleDropTarget odt = new OleDropTarget(this, _owner);
+            var odt = new OleDropTarget(this, _owner);
+
             if (OleContext.Current?.RegisterDragDrop(Handle, odt) ?? false)
+            {
                 _dropTarget = odt;
-        }
-
-        private Point DipFromLParam(IntPtr lParam)
-        {
-            return new Point((short)(ToInt32(lParam) & 0xffff), (short)(ToInt32(lParam) >> 16)) / Scaling;
-        }
-
-        private PixelPoint PointFromLParam(IntPtr lParam)
-        {
-            return new PixelPoint((short)(ToInt32(lParam) & 0xffff), (short)(ToInt32(lParam) >> 16));
-        }
-
-        private Point ScreenToClient(Point point)
-        {
-            var p = new UnmanagedMethods.POINT { X = (int)point.X, Y = (int)point.Y };
-            UnmanagedMethods.ScreenToClient(_hwnd, ref p);
-            return new Point(p.X, p.Y);
+            }
         }
 
         private void ShowWindow(WindowState state)
         {
-            UnmanagedMethods.ShowWindowCommand command;
+            ShowWindowCommand command;
 
             switch (state)
             {
@@ -923,12 +585,10 @@ namespace Avalonia.Win32
 
             if (monitor != IntPtr.Zero)
             {
-                MONITORINFO monitorInfo = MONITORINFO.Create();
+                var monitorInfo = MONITORINFO.Create();
 
                 if (GetMonitorInfo(monitor, ref monitorInfo))
                 {
-                    RECT rcMonitorArea = monitorInfo.rcMonitor;
-
                     var x = monitorInfo.rcWork.left;
                     var y = monitorInfo.rcWork.top;
                     var cx = Math.Abs(monitorInfo.rcWork.right - x);
@@ -939,149 +599,131 @@ namespace Avalonia.Win32
             }
         }
 
-        public void SetIcon(IWindowIconImpl icon)
-        {
-            var impl = (IconImpl)icon;
-            var hIcon = impl?.HIcon ?? IntPtr.Zero;
-            UnmanagedMethods.PostMessage(_hwnd, (int)UnmanagedMethods.WindowsMessage.WM_SETICON,
-                new IntPtr((int)UnmanagedMethods.Icons.ICON_BIG), hIcon);
-        }
+        private WindowStyles GetStyle() => (WindowStyles)GetWindowLong(_hwnd, (int)WindowLongParam.GWL_STYLE);
 
-        private static int ToInt32(IntPtr ptr)
-        {
-            if (IntPtr.Size == 4) return ptr.ToInt32();
+        private WindowStyles GetExtendedStyle() => (WindowStyles)GetWindowLong(_hwnd, (int)WindowLongParam.GWL_EXSTYLE);
 
-            return (int)(ptr.ToInt64() & 0xffffffff);
-        }
+        private void SetStyle(WindowStyles style) => SetWindowLong(_hwnd, (int)WindowLongParam.GWL_STYLE, (uint)style);
 
+        private void SetExtendedStyle(WindowStyles style) =>
+            SetWindowLong(_hwnd, (int)WindowLongParam.GWL_EXSTYLE, (uint)style);
 
-        public void ShowTaskbarIcon(bool value)
+        private void UpdateEnabled()
         {
-            if (_taskbarIcon == value)
-            {
-                return;
-            }
+            EnableWindow(_hwnd, _disabledBy.Count == 0);
+        }
 
-            _taskbarIcon = value;
+        private void UpdateWindowProperties(WindowProperties newProperties)
+        {
+            var oldProperties = _windowProperties;
 
-            var style = (UnmanagedMethods.WindowStyles)UnmanagedMethods.GetWindowLong(_hwnd, (int)UnmanagedMethods.WindowLongParam.GWL_EXSTYLE);
+            _windowProperties = newProperties;
 
-            style &= ~(UnmanagedMethods.WindowStyles.WS_VISIBLE);
+            if (oldProperties.ShowInTaskbar != newProperties.ShowInTaskbar)
+            {
+                var exStyle = GetExtendedStyle();
 
-            style |= UnmanagedMethods.WindowStyles.WS_EX_TOOLWINDOW;
+                if (newProperties.ShowInTaskbar)
+                {
+                    exStyle |= WindowStyles.WS_EX_APPWINDOW;
+                }
+                else
+                {
+                    exStyle &= ~WindowStyles.WS_EX_APPWINDOW;
+                }
 
-            if (value)
-                style |= UnmanagedMethods.WindowStyles.WS_EX_APPWINDOW;
-            else
-                style &= ~(UnmanagedMethods.WindowStyles.WS_EX_APPWINDOW);
+                SetExtendedStyle(exStyle);
 
-            WINDOWPLACEMENT windowPlacement = UnmanagedMethods.WINDOWPLACEMENT.Default;
-            if (UnmanagedMethods.GetWindowPlacement(_hwnd, ref windowPlacement))
-            {
-                //Toggle to make the styles stick
-                UnmanagedMethods.ShowWindow(_hwnd, ShowWindowCommand.Hide);
-                UnmanagedMethods.SetWindowLong(_hwnd, (int)UnmanagedMethods.WindowLongParam.GWL_EXSTYLE, (uint)style);
-                UnmanagedMethods.ShowWindow(_hwnd, windowPlacement.ShowCmd);
+                // TODO: To hide non-owned window from taskbar we need to parent it to a hidden window.
+                // Otherwise it will still show in the taskbar.
             }
-        }
 
-        private void UpdateWMStyles(Action change)
-        {
-            var oldDecorated = _decorated;
+            if (oldProperties.IsResizable != newProperties.IsResizable)
+            {
+                var style = GetStyle();
 
-            var oldThickness = BorderThickness;
+                if (newProperties.IsResizable)
+                {
+                    style |= WindowStyles.WS_SIZEFRAME;
+                }
+                else
+                {
+                    style &= ~WindowStyles.WS_SIZEFRAME;
+                }
+
+                SetStyle(style);
+            }
 
-            change();
+            if (oldProperties.Decorations != newProperties.Decorations)
+            {
+                var style = GetStyle();
 
-            var style = (WindowStyles)GetWindowLong(_hwnd, (int)WindowLongParam.GWL_STYLE);
+                const WindowStyles fullDecorationFlags = WindowStyles.WS_CAPTION | WindowStyles.WS_SYSMENU;
 
-            const WindowStyles controlledFlags = WindowStyles.WS_OVERLAPPEDWINDOW;
+                if (newProperties.Decorations == SystemDecorations.Full)
+                {
+                    style |= fullDecorationFlags;
+                }
+                else
+                {
+                    style &= ~fullDecorationFlags;
+                }
 
-            style = style | controlledFlags ^ controlledFlags;
+                var margins = new MARGINS
+                {
+                    cyBottomHeight = newProperties.Decorations == SystemDecorations.BorderOnly ? 1 : 0
+                };
 
-            style |= WindowStyles.WS_OVERLAPPEDWINDOW;
+                DwmExtendFrameIntoClientArea(_hwnd, ref margins);
 
-            if (_decorated != SystemDecorations.Full)
-            {
-                style ^= (WindowStyles.WS_CAPTION | WindowStyles.WS_SYSMENU);
-            }
+                GetClientRect(_hwnd, out var oldClientRect);
+                var oldClientRectOrigin = new POINT();
+                ClientToScreen(_hwnd, ref oldClientRectOrigin);
+                oldClientRect.Offset(oldClientRectOrigin);
 
-            if (!_resizable)
-            {
-                style ^= (WindowStyles.WS_SIZEFRAME);
-            }
+                SetStyle(style);
 
-            MARGINS margins = new MARGINS();
-            margins.cyBottomHeight = _decorated == SystemDecorations.BorderOnly ? 1 : 0;
-            UnmanagedMethods.DwmExtendFrameIntoClientArea(_hwnd, ref margins);
-
-            GetClientRect(_hwnd, out var oldClientRect);
-            var oldClientRectOrigin = new UnmanagedMethods.POINT();
-            ClientToScreen(_hwnd, ref oldClientRectOrigin);
-            oldClientRect.Offset(oldClientRectOrigin);
-            
-            
-            SetWindowLong(_hwnd, (int)WindowLongParam.GWL_STYLE, (uint)style);
-
-            UnmanagedMethods.GetWindowRect(_hwnd, out var windowRect);
-            bool frameUpdated = false;
-            if (oldDecorated != _decorated)
-            {
                 var newRect = oldClientRect;
-                if (_decorated == SystemDecorations.Full)
-                    AdjustWindowRectEx(ref newRect, (uint)style, false,
-                        GetWindowLong(_hwnd, (int)WindowLongParam.GWL_EXSTYLE));
-                SetWindowPos(_hwnd, IntPtr.Zero, newRect.left, newRect.top, newRect.Width, newRect.Height,
-                    SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOACTIVATE | SetWindowPosFlags.SWP_FRAMECHANGED);
-                frameUpdated = true;
-            }
 
-            if (!frameUpdated)
-                SetWindowPos(_hwnd, IntPtr.Zero, 0, 0, 0, 0,
-                    SetWindowPosFlags.SWP_FRAMECHANGED | SetWindowPosFlags.SWP_NOZORDER |
-                    SetWindowPosFlags.SWP_NOACTIVATE
-                    | SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE);
-        }
+                if (newProperties.Decorations == SystemDecorations.Full)
+                {
+                    AdjustWindowRectEx(ref newRect, (uint)style, false, (uint)GetExtendedStyle());
+                }
 
-        public void CanResize(bool value)
-        {
-            if (value == _resizable)
-            {
-                return;
+                SetWindowPos(_hwnd, IntPtr.Zero, newRect.left, newRect.top, newRect.Width, newRect.Height,
+                    SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOACTIVATE |
+                    SetWindowPosFlags.SWP_FRAMECHANGED);
             }
-
-            UpdateWMStyles(()=> _resizable = value);
         }
 
-        public void SetTopmost(bool value)
+#if USE_MANAGED_DRAG
+        private Point ScreenToClient(Point point)
         {
-            if (value == _topmost)
-            {
-                return;
-            }
-
-            IntPtr hWndInsertAfter = value ? WindowPosZOrder.HWND_TOPMOST : WindowPosZOrder.HWND_NOTOPMOST;
-            UnmanagedMethods.SetWindowPos(_hwnd,
-                   hWndInsertAfter,
-                   0, 0, 0, 0,
-                   SetWindowPosFlags.SWP_NOMOVE | SetWindowPosFlags.SWP_NOSIZE | SetWindowPosFlags.SWP_NOACTIVATE);
-
-            _topmost = value;
+            var p = new UnmanagedMethods.POINT { X = (int)point.X, Y = (int)point.Y };
+            UnmanagedMethods.ScreenToClient(_hwnd, ref p);
+            return new Point(p.X, p.Y);
         }
+#endif
 
         PixelSize EglGlPlatformSurface.IEglWindowGlPlatformSurfaceInfo.Size
         {
             get
             {
-                RECT rect;
-                GetClientRect(_hwnd, out rect);
+                GetClientRect(_hwnd, out var rect);
+
                 return new PixelSize(
                     Math.Max(1, rect.right - rect.left),
                     Math.Max(1, rect.bottom - rect.top));
             }
         }
+
         IntPtr EglGlPlatformSurface.IEglWindowGlPlatformSurfaceInfo.Handle => Handle.Handle;
 
-        private static int HighWord(int param) => param >> 16;
+        private struct WindowProperties
+        {
+            public bool ShowInTaskbar;
+            public bool IsResizable;
+            public SystemDecorations Decorations;
+        }
     }
 }

From 0d5af630f986829ea70d5a45f576f78f357fc66a Mon Sep 17 00:00:00 2001
From: Dariusz Komosinski <darek.komosinski@gmail.com>
Date: Mon, 23 Mar 2020 21:28:25 +0100
Subject: [PATCH 08/29] Cleanup even more.

---
 .../Avalonia.Win32/WindowImpl.WndProc.cs      | 104 ++++++++++++++++--
 src/Windows/Avalonia.Win32/WindowImpl.cs      |  76 +++++++------
 2 files changed, 136 insertions(+), 44 deletions(-)

diff --git a/src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs b/src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs
index d595ffbfbf..14b22fea1b 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs
@@ -26,31 +26,40 @@ namespace Avalonia.Win32
             switch ((WindowsMessage)msg)
             {
                 case WindowsMessage.WM_ACTIVATE:
+                {
                     var wa = (WindowActivate)(ToInt32(wParam) & 0xffff);
 
                     switch (wa)
                     {
                         case WindowActivate.WA_ACTIVE:
                         case WindowActivate.WA_CLICKACTIVE:
+                        {
                             Activated?.Invoke();
                             break;
+                        }
 
                         case WindowActivate.WA_INACTIVE:
+                        {
                             Deactivated?.Invoke();
                             break;
+                        }
                     }
 
                     return IntPtr.Zero;
+                }
 
                 case WindowsMessage.WM_NCCALCSIZE:
+                {
                     if (ToInt32(wParam) == 1 && !HasFullDecorations)
                     {
                         return IntPtr.Zero;
                     }
 
                     break;
+                }
 
                 case WindowsMessage.WM_CLOSE:
+                {
                     bool? preventClosing = Closing?.Invoke();
                     if (preventClosing == true)
                     {
@@ -58,13 +67,16 @@ namespace Avalonia.Win32
                     }
 
                     break;
+                }
 
                 case WindowsMessage.WM_DESTROY:
+                {
                     //Window doesn't exist anymore
                     _hwnd = IntPtr.Zero;
                     //Remove root reference to this class, so unmanaged delegate can be collected
                     s_instances.Remove(this);
                     Closed?.Invoke();
+
                     if (_parent != null)
                     {
                         _parent._disabledBy.Remove(this);
@@ -76,8 +88,10 @@ namespace Avalonia.Win32
                     //Free other resources
                     Dispose();
                     return IntPtr.Zero;
+                }
 
                 case WindowsMessage.WM_DPICHANGED:
+                {
                     var dpi = ToInt32(wParam) & 0xffff;
                     var newDisplayRect = Marshal.PtrToStructure<RECT>(lParam);
                     _scaling = dpi / 96.0;
@@ -91,9 +105,11 @@ namespace Avalonia.Win32
                         SetWindowPosFlags.SWP_NOZORDER |
                         SetWindowPosFlags.SWP_NOACTIVATE);
                     return IntPtr.Zero;
+                }
 
                 case WindowsMessage.WM_KEYDOWN:
                 case WindowsMessage.WM_SYSKEYDOWN:
+                {
                     e = new RawKeyEventArgs(
                         WindowsKeyboardDevice.Instance,
                         timestamp,
@@ -102,13 +118,17 @@ namespace Avalonia.Win32
                         KeyInterop.KeyFromVirtualKey(ToInt32(wParam), ToInt32(lParam)),
                         WindowsKeyboardDevice.Instance.Modifiers);
                     break;
+                }
 
                 case WindowsMessage.WM_MENUCHAR:
+                {
                     // mute the system beep
-                    return (IntPtr)((Int32)MenuCharParam.MNC_CLOSE << 16);
+                    return (IntPtr)((int)MenuCharParam.MNC_CLOSE << 16);
+                }
 
                 case WindowsMessage.WM_KEYUP:
                 case WindowsMessage.WM_SYSKEYUP:
+                {
                     e = new RawKeyEventArgs(
                         WindowsKeyboardDevice.Instance,
                         timestamp,
@@ -117,7 +137,9 @@ namespace Avalonia.Win32
                         KeyInterop.KeyFromVirtualKey(ToInt32(wParam), ToInt32(lParam)),
                         WindowsKeyboardDevice.Instance.Modifiers);
                     break;
+                }
                 case WindowsMessage.WM_CHAR:
+                {
                     // Ignore control chars
                     if (ToInt32(wParam) >= 32)
                     {
@@ -126,13 +148,18 @@ namespace Avalonia.Win32
                     }
 
                     break;
+                }
 
                 case WindowsMessage.WM_LBUTTONDOWN:
                 case WindowsMessage.WM_RBUTTONDOWN:
                 case WindowsMessage.WM_MBUTTONDOWN:
                 case WindowsMessage.WM_XBUTTONDOWN:
+                {
                     if (ShouldIgnoreTouchEmulatedMessage())
+                    {
                         break;
+                    }
+
                     e = new RawPointerEventArgs(
                         _mouseDevice,
                         timestamp,
@@ -149,13 +176,18 @@ namespace Avalonia.Win32
                         },
                         DipFromLParam(lParam), GetMouseModifiers(wParam));
                     break;
+                }
 
                 case WindowsMessage.WM_LBUTTONUP:
                 case WindowsMessage.WM_RBUTTONUP:
                 case WindowsMessage.WM_MBUTTONUP:
                 case WindowsMessage.WM_XBUTTONUP:
+                {
                     if (ShouldIgnoreTouchEmulatedMessage())
+                    {
                         break;
+                    }
+
                     e = new RawPointerEventArgs(
                         _mouseDevice,
                         timestamp,
@@ -172,10 +204,15 @@ namespace Avalonia.Win32
                         },
                         DipFromLParam(lParam), GetMouseModifiers(wParam));
                     break;
+                }
 
                 case WindowsMessage.WM_MOUSEMOVE:
+                {
                     if (ShouldIgnoreTouchEmulatedMessage())
+                    {
                         break;
+                    }
+
                     if (!_trackingMouse)
                     {
                         var tm = new TRACKMOUSEEVENT
@@ -197,8 +234,10 @@ namespace Avalonia.Win32
                         DipFromLParam(lParam), GetMouseModifiers(wParam));
 
                     break;
+                }
 
                 case WindowsMessage.WM_MOUSEWHEEL:
+                {
                     e = new RawMouseWheelEventArgs(
                         _mouseDevice,
                         timestamp,
@@ -206,8 +245,10 @@ namespace Avalonia.Win32
                         PointToClient(PointFromLParam(lParam)),
                         new Vector(0, (ToInt32(wParam) >> 16) / wheelDelta), GetMouseModifiers(wParam));
                     break;
+                }
 
                 case WindowsMessage.WM_MOUSEHWHEEL:
+                {
                     e = new RawMouseWheelEventArgs(
                         _mouseDevice,
                         timestamp,
@@ -215,8 +256,10 @@ namespace Avalonia.Win32
                         PointToClient(PointFromLParam(lParam)),
                         new Vector(-(ToInt32(wParam) >> 16) / wheelDelta, 0), GetMouseModifiers(wParam));
                     break;
+                }
 
                 case WindowsMessage.WM_MOUSELEAVE:
+                {
                     _trackingMouse = false;
                     e = new RawPointerEventArgs(
                         _mouseDevice,
@@ -225,11 +268,13 @@ namespace Avalonia.Win32
                         RawPointerEventType.LeaveWindow,
                         new Point(-1, -1), WindowsKeyboardDevice.Instance.Modifiers);
                     break;
+                }
 
                 case WindowsMessage.WM_NCLBUTTONDOWN:
                 case WindowsMessage.WM_NCRBUTTONDOWN:
                 case WindowsMessage.WM_NCMBUTTONDOWN:
                 case WindowsMessage.WM_NCXBUTTONDOWN:
+                {
                     e = new RawPointerEventArgs(
                         _mouseDevice,
                         timestamp,
@@ -247,14 +292,15 @@ namespace Avalonia.Win32
                         },
                         PointToClient(PointFromLParam(lParam)), GetMouseModifiers(wParam));
                     break;
+                }
                 case WindowsMessage.WM_TOUCH:
+                {
                     var touchInputCount = wParam.ToInt32();
 
                     var pTouchInputs = stackalloc TOUCHINPUT[touchInputCount];
                     var touchInputs = new Span<TOUCHINPUT>(pTouchInputs, touchInputCount);
 
-                    if (GetTouchInputInfo(lParam, (uint)touchInputCount, pTouchInputs,
-                        Marshal.SizeOf<TOUCHINPUT>()))
+                    if (GetTouchInputInfo(lParam, (uint)touchInputCount, pTouchInputs, Marshal.SizeOf<TOUCHINPUT>()))
                     {
                         foreach (var touchInput in touchInputs)
                         {
@@ -275,27 +321,32 @@ namespace Avalonia.Win32
                     }
 
                     break;
+                }
                 case WindowsMessage.WM_NCPAINT:
+                {
                     if (!HasFullDecorations)
                     {
                         return IntPtr.Zero;
                     }
 
                     break;
+                }
 
                 case WindowsMessage.WM_NCACTIVATE:
+                {
                     if (!HasFullDecorations)
                     {
                         return new IntPtr(1);
                     }
 
                     break;
+                }
 
                 case WindowsMessage.WM_PAINT:
+                {
                     using (_rendererLock.Lock())
                     {
-                        PAINTSTRUCT ps;
-                        if (BeginPaint(_hwnd, out ps) != IntPtr.Zero)
+                        if (BeginPaint(_hwnd, out PAINTSTRUCT ps) != IntPtr.Zero)
                         {
                             var f = Scaling;
                             var r = ps.rcPaint;
@@ -306,8 +357,10 @@ namespace Avalonia.Win32
                     }
 
                     return IntPtr.Zero;
+                }
 
                 case WindowsMessage.WM_SIZE:
+                {
                     using (_rendererLock.Lock())
                     {
                         // Do nothing here, just block until the pending frame render is completed on the render thread
@@ -334,38 +387,52 @@ namespace Avalonia.Win32
                     }
 
                     return IntPtr.Zero;
+                }
 
                 case WindowsMessage.WM_MOVE:
+                {
                     PositionChanged?.Invoke(new PixelPoint((short)(ToInt32(lParam) & 0xffff),
                         (short)(ToInt32(lParam) >> 16)));
                     return IntPtr.Zero;
+                }
 
                 case WindowsMessage.WM_GETMINMAXINFO:
-
+                {
                     MINMAXINFO mmi = Marshal.PtrToStructure<MINMAXINFO>(lParam);
 
                     if (_minSize.Width > 0)
+                    {
                         mmi.ptMinTrackSize.X =
                             (int)((_minSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right);
+                    }
 
                     if (_minSize.Height > 0)
+                    {
                         mmi.ptMinTrackSize.Y =
                             (int)((_minSize.Height * Scaling) + BorderThickness.Top + BorderThickness.Bottom);
+                    }
 
-                    if (!Double.IsInfinity(_maxSize.Width) && _maxSize.Width > 0)
+                    if (!double.IsInfinity(_maxSize.Width) && _maxSize.Width > 0)
+                    {
                         mmi.ptMaxTrackSize.X =
                             (int)((_maxSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right);
+                    }
 
-                    if (!Double.IsInfinity(_maxSize.Height) && _maxSize.Height > 0)
+                    if (!double.IsInfinity(_maxSize.Height) && _maxSize.Height > 0)
+                    {
                         mmi.ptMaxTrackSize.Y =
                             (int)((_maxSize.Height * Scaling) + BorderThickness.Top + BorderThickness.Bottom);
+                    }
 
                     Marshal.StructureToPtr(mmi, lParam, true);
                     return IntPtr.Zero;
+                }
 
                 case WindowsMessage.WM_DISPLAYCHANGE:
+                {
                     (Screen as ScreenImpl)?.InvalidateScreensCache();
                     return IntPtr.Zero;
+                }
             }
 
 #if USE_MANAGED_DRAG
@@ -384,7 +451,9 @@ namespace Avalonia.Win32
             }
 
             using (_rendererLock.Lock())
+            {
                 return DefWindowProc(hWnd, msg, wParam, lParam);
+            }
         }
 
         private static int ToInt32(IntPtr ptr)
@@ -410,7 +479,10 @@ namespace Avalonia.Win32
         private bool ShouldIgnoreTouchEmulatedMessage()
         {
             if (!_multitouch)
+            {
                 return false;
+            }
+
             var marker = 0xFF515700L;
             var info = GetMessageExtraInfo().ToInt64();
             return (info & marker) == marker;
@@ -420,16 +492,32 @@ namespace Avalonia.Win32
         {
             var keys = (ModifierKeys)ToInt32(wParam);
             var modifiers = WindowsKeyboardDevice.Instance.Modifiers;
+
             if (keys.HasFlagCustom(ModifierKeys.MK_LBUTTON))
+            {
                 modifiers |= RawInputModifiers.LeftMouseButton;
+            }
+
             if (keys.HasFlagCustom(ModifierKeys.MK_RBUTTON))
+            {
                 modifiers |= RawInputModifiers.RightMouseButton;
+            }
+
             if (keys.HasFlagCustom(ModifierKeys.MK_MBUTTON))
+            {
                 modifiers |= RawInputModifiers.MiddleMouseButton;
+            }
+
             if (keys.HasFlagCustom(ModifierKeys.MK_XBUTTON1))
+            {
                 modifiers |= RawInputModifiers.XButton1MouseButton;
+            }
+
             if (keys.HasFlagCustom(ModifierKeys.MK_XBUTTON2))
+            {
                 modifiers |= RawInputModifiers.XButton2MouseButton;
+            }
+
             return modifiers;
         }
     }
diff --git a/src/Windows/Avalonia.Win32/WindowImpl.cs b/src/Windows/Avalonia.Win32/WindowImpl.cs
index f82bea0d49..3c92f77365 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.cs
@@ -312,15 +312,6 @@ namespace Avalonia.Win32
             }
         }
 
-        public void SetSystemDecorations(SystemDecorations value)
-        {
-            var newWindowProperties = _windowProperties;
-
-            newWindowProperties.Decorations = value;
-
-            UpdateWindowProperties(newWindowProperties);
-        }
-
         public void Invalidate(Rect rect)
         {
             var scaling = Scaling;
@@ -356,11 +347,6 @@ namespace Avalonia.Win32
             CreateDropTarget();
         }
 
-        public void SetTitle(string title)
-        {
-            SetWindowText(_hwnd, title);
-        }
-
         public void Hide()
         {
             if (_parent != null)
@@ -407,30 +393,20 @@ namespace Avalonia.Win32
 #endif
         }
 
+        public void SetTitle(string title)
+        {
+            SetWindowText(_hwnd, title);
+        }
+
         public void SetCursor(IPlatformHandle cursor)
         {
             var hCursor = cursor?.Handle ?? DefaultCursor;
             SetClassLong(_hwnd, ClassLongIndex.GCLP_HCURSOR, hCursor);
 
             if (_owner.IsPointerOver)
+            {
                 UnmanagedMethods.SetCursor(hCursor);
-        }
-
-        protected virtual IntPtr CreateWindowOverride(ushort atom)
-        {
-            return CreateWindowEx(
-                0,
-                atom,
-                null,
-                (int)WindowStyles.WS_OVERLAPPEDWINDOW,
-                CW_USEDEFAULT,
-                CW_USEDEFAULT,
-                CW_USEDEFAULT,
-                CW_USEDEFAULT,
-                IntPtr.Zero,
-                IntPtr.Zero,
-                IntPtr.Zero,
-                IntPtr.Zero);
+            }
         }
 
         public void SetIcon(IWindowIconImpl icon)
@@ -459,6 +435,15 @@ namespace Avalonia.Win32
             UpdateWindowProperties(newWindowProperties);
         }
 
+        public void SetSystemDecorations(SystemDecorations value)
+        {
+            var newWindowProperties = _windowProperties;
+
+            newWindowProperties.Decorations = value;
+
+            UpdateWindowProperties(newWindowProperties);
+        }
+
         public void SetTopmost(bool value)
         {
             if (value == _topmost)
@@ -475,6 +460,23 @@ namespace Avalonia.Win32
             _topmost = value;
         }
 
+        protected virtual IntPtr CreateWindowOverride(ushort atom)
+        {
+            return CreateWindowEx(
+                0,
+                atom,
+                null,
+                (int)WindowStyles.WS_OVERLAPPEDWINDOW,
+                CW_USEDEFAULT,
+                CW_USEDEFAULT,
+                CW_USEDEFAULT,
+                CW_USEDEFAULT,
+                IntPtr.Zero,
+                IntPtr.Zero,
+                IntPtr.Zero,
+                IntPtr.Zero);
+        }
+
         private void CreateWindow()
         {
             // Ensure that the delegate doesn't get garbage collected by storing it as a field.
@@ -482,12 +484,13 @@ namespace Avalonia.Win32
 
             _className = $"Avalonia-{Guid.NewGuid().ToString()}";
 
+            // Unique DC helps with performance when using Gpu based rendering
+            const ClassStyles windowClassStyle = ClassStyles.CS_OWNDC | ClassStyles.CS_HREDRAW | ClassStyles.CS_VREDRAW;
+
             var wndClassEx = new WNDCLASSEX
             {
                 cbSize = Marshal.SizeOf<WNDCLASSEX>(),
-                style =
-                    (int)(ClassStyles.CS_OWNDC | ClassStyles.CS_HREDRAW |
-                          ClassStyles.CS_VREDRAW), // Unique DC helps with performance when using Gpu based rendering
+                style = (int)windowClassStyle,
                 lpfnWndProc = _wndProcDelegate,
                 hInstance = GetModuleHandle(null),
                 hCursor = DefaultCursor,
@@ -605,8 +608,7 @@ namespace Avalonia.Win32
 
         private void SetStyle(WindowStyles style) => SetWindowLong(_hwnd, (int)WindowLongParam.GWL_STYLE, (uint)style);
 
-        private void SetExtendedStyle(WindowStyles style) =>
-            SetWindowLong(_hwnd, (int)WindowLongParam.GWL_EXSTYLE, (uint)style);
+        private void SetExtendedStyle(WindowStyles style) => SetWindowLong(_hwnd, (int)WindowLongParam.GWL_EXSTYLE, (uint)style);
 
         private void UpdateEnabled()
         {
@@ -617,6 +619,8 @@ namespace Avalonia.Win32
         {
             var oldProperties = _windowProperties;
 
+            // Calling SetWindowPos will cause events to be sent and we need to respond
+            // according to the new values already.
             _windowProperties = newProperties;
 
             if (oldProperties.ShowInTaskbar != newProperties.ShowInTaskbar)

From 177180c9096be50b29118b4f27981f22b4983079 Mon Sep 17 00:00:00 2001
From: Dariusz Komosinski <darek.komosinski@gmail.com>
Date: Mon, 30 Mar 2020 00:03:55 +0200
Subject: [PATCH 09/29] Clarify magic number.

---
 src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs b/src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs
index 14b22fea1b..3ea8c1e48f 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs
@@ -483,7 +483,10 @@ namespace Avalonia.Win32
                 return false;
             }
 
-            var marker = 0xFF515700L;
+            // MI_WP_SIGNATURE
+            // https://docs.microsoft.com/en-us/windows/win32/tablet/system-events-and-mouse-messages
+            const long marker = 0xFF515700L;
+
             var info = GetMessageExtraInfo().ToInt64();
             return (info & marker) == marker;
         }

From 8e780cb01afbf2440df1cbe65254b8f7daa715d0 Mon Sep 17 00:00:00 2001
From: Dariusz Komosinski <darek.komosinski@gmail.com>
Date: Mon, 30 Mar 2020 00:04:17 +0200
Subject: [PATCH 10/29] Fix managed drag and drop.

---
 src/Windows/Avalonia.Win32/WindowImpl.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Windows/Avalonia.Win32/WindowImpl.cs b/src/Windows/Avalonia.Win32/WindowImpl.cs
index 3c92f77365..e21bac76d1 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.cs
@@ -385,7 +385,7 @@ namespace Avalonia.Win32
         public void BeginResizeDrag(WindowEdge edge, PointerPressedEventArgs e)
         {
 #if USE_MANAGED_DRAG
-            _managedDrag.BeginResizeDrag(edge, ScreenToClient(MouseDevice.Position));
+            _managedDrag.BeginResizeDrag(edge, ScreenToClient(MouseDevice.Position.ToPoint(_scaling)));
 #else
             _mouseDevice.Capture(null);
             DefWindowProc(_hwnd, (int)WindowsMessage.WM_NCLBUTTONDOWN,

From cfb62859f5139bc9ccc410a9ad4b4150b2d963dd Mon Sep 17 00:00:00 2001
From: Dariusz Komosinski <darek.komosinski@gmail.com>
Date: Mon, 30 Mar 2020 00:04:31 +0200
Subject: [PATCH 11/29] Cleanup code.

---
 src/Windows/Avalonia.Win32/WindowImpl.cs | 19 ++++++-------------
 1 file changed, 6 insertions(+), 13 deletions(-)

diff --git a/src/Windows/Avalonia.Win32/WindowImpl.cs b/src/Windows/Avalonia.Win32/WindowImpl.cs
index e21bac76d1..973eb8437d 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.cs
@@ -165,11 +165,7 @@ namespace Avalonia.Win32
 
         public IScreenImpl Screen { get; }
 
-        public IPlatformHandle Handle
-        {
-            get;
-            private set;
-        }
+        public IPlatformHandle Handle { get; private set; }
 
         public Size MaxClientSize
         {
@@ -191,15 +187,12 @@ namespace Avalonia.Win32
                 var placement = default(WINDOWPLACEMENT);
                 GetWindowPlacement(_hwnd, ref placement);
 
-                switch (placement.ShowCmd)
+                return placement.ShowCmd switch
                 {
-                    case ShowWindowCommand.Maximize:
-                        return WindowState.Maximized;
-                    case ShowWindowCommand.Minimize:
-                        return WindowState.Minimized;
-                    default:
-                        return WindowState.Normal;
-                }
+                    ShowWindowCommand.Maximize => WindowState.Maximized,
+                    ShowWindowCommand.Minimize => WindowState.Minimized,
+                    _ => WindowState.Normal
+                };
             }
 
             set

From bce28b3d35bb71bc4a9f5f2f5a1a292734aa6e4a Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Tue, 31 Mar 2020 17:57:41 +0300
Subject: [PATCH 12/29] Fixed InitialFileName for GTK-based file dialog

---
 samples/ControlCatalog/Pages/DialogsPage.xaml.cs       | 5 +++--
 src/Avalonia.X11/NativeDialogs/Gtk.cs                  | 3 +++
 src/Avalonia.X11/NativeDialogs/GtkNativeFileDialogs.cs | 2 +-
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/samples/ControlCatalog/Pages/DialogsPage.xaml.cs b/samples/ControlCatalog/Pages/DialogsPage.xaml.cs
index d207689223..6f5e503fb3 100644
--- a/samples/ControlCatalog/Pages/DialogsPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/DialogsPage.xaml.cs
@@ -42,14 +42,15 @@ namespace ControlCatalog.Pages
                 new SaveFileDialog()
                 {
                     Title = "Save file",
-                    Filters = GetFilters()
+                    Filters = GetFilters(),
+                    InitialFileName = "test.txt"
                 }.ShowAsync(GetWindow());
             };
             this.FindControl<Button>("SelectFolder").Click += delegate
             {
                 new OpenFolderDialog()
                 {
-                    Title = "Select folder"
+                    Title = "Select folder",
                 }.ShowAsync(GetWindow());
             };
             this.FindControl<Button>("DecoratedWindow").Click += delegate
diff --git a/src/Avalonia.X11/NativeDialogs/Gtk.cs b/src/Avalonia.X11/NativeDialogs/Gtk.cs
index 42acb087bc..9a12479fac 100644
--- a/src/Avalonia.X11/NativeDialogs/Gtk.cs
+++ b/src/Avalonia.X11/NativeDialogs/Gtk.cs
@@ -190,6 +190,9 @@ namespace Avalonia.X11.NativeDialogs
         [DllImport(GtkName)]
         public static extern void gtk_file_chooser_set_filename(IntPtr chooser, Utf8Buffer file);
 
+        [DllImport(GtkName)]
+        public static extern void gtk_file_chooser_set_current_name(IntPtr chooser, Utf8Buffer file);
+        
         [DllImport(GtkName)]
         public static extern IntPtr gtk_file_filter_new();
         
diff --git a/src/Avalonia.X11/NativeDialogs/GtkNativeFileDialogs.cs b/src/Avalonia.X11/NativeDialogs/GtkNativeFileDialogs.cs
index ffd1c1b57e..492f5f824f 100644
--- a/src/Avalonia.X11/NativeDialogs/GtkNativeFileDialogs.cs
+++ b/src/Avalonia.X11/NativeDialogs/GtkNativeFileDialogs.cs
@@ -91,7 +91,7 @@ namespace Avalonia.X11.NativeDialogs
                 gtk_dialog_add_button(dlg, open, GtkResponseType.Cancel);
             if (initialFileName != null)
                 using (var fn = new Utf8Buffer(initialFileName))
-                    gtk_file_chooser_set_filename(dlg, fn);
+                    gtk_file_chooser_set_current_name(dlg, fn);
             gtk_window_present(dlg);
             return tcs.Task;
         }

From 182cda5275229c59d50d62cb1ba1fc1bee335f99 Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Tue, 31 Mar 2020 21:31:10 +0300
Subject: [PATCH 13/29] [X11, FlyWM] Completely remove WM_TRANSIENT_FOR
 property

---
 src/Avalonia.X11/X11Window.cs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs
index 8419e7dab2..2d124fff67 100644
--- a/src/Avalonia.X11/X11Window.cs
+++ b/src/Avalonia.X11/X11Window.cs
@@ -758,7 +758,15 @@ namespace Avalonia.X11
             _transientParent = window;
             _transientParent?._transientChildren.Add(this);
             if (informServer)
-                XSetTransientForHint(_x11.Display, _handle, _transientParent?._handle ?? IntPtr.Zero);
+                SetTransientForHint(_transientParent?._handle);
+        }
+
+        void SetTransientForHint(IntPtr? parent)
+        {
+            if (parent == null || parent == IntPtr.Zero)
+                XDeleteProperty(_x11.Display, _handle, _x11.Atoms.XA_WM_TRANSIENT_FOR);
+            else
+                XSetTransientForHint(_x11.Display, _handle, parent.Value);
         }
 
         public void Show()

From b85fd31d03920e91a75ece1bb004e39977e30876 Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Tue, 31 Mar 2020 19:33:45 +0300
Subject: [PATCH 14/29] Immediate rendering support for X11 platform via render
 loop

---
 src/Avalonia.X11/X11ImmediateRendererProxy.cs | 107 ++++++++++++++++++
 src/Avalonia.X11/X11Platform.cs               |   1 +
 src/Avalonia.X11/X11Window.cs                 |  20 ++--
 3 files changed, 116 insertions(+), 12 deletions(-)
 create mode 100644 src/Avalonia.X11/X11ImmediateRendererProxy.cs

diff --git a/src/Avalonia.X11/X11ImmediateRendererProxy.cs b/src/Avalonia.X11/X11ImmediateRendererProxy.cs
new file mode 100644
index 0000000000..f7bc7f9711
--- /dev/null
+++ b/src/Avalonia.X11/X11ImmediateRendererProxy.cs
@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using Avalonia.Rendering;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+
+namespace Avalonia.X11
+{
+    public class X11ImmediateRendererProxy : IRenderer, IRenderLoopTask
+    {
+        private readonly IRenderLoop _loop;
+        private ImmediateRenderer _renderer;
+        private bool _invalidated;
+        private object _lock = new object();
+
+        public X11ImmediateRendererProxy(IVisual root, IRenderLoop loop)
+        {
+            _loop = loop;
+            _renderer = new ImmediateRenderer(root);
+            
+        }
+
+        public void Dispose()
+        {
+            _renderer.Dispose();
+        }
+
+        public bool DrawFps
+        {
+            get => _renderer.DrawFps;
+            set => _renderer.DrawFps = value;
+        }
+
+        public bool DrawDirtyRects
+        {
+            get => _renderer.DrawDirtyRects;
+            set => _renderer.DrawDirtyRects = value;
+        }
+
+        public event EventHandler<SceneInvalidatedEventArgs> SceneInvalidated
+        {
+            add => _renderer.SceneInvalidated += value;
+            remove => _renderer.SceneInvalidated -= value;
+        }
+
+        public void AddDirty(IVisual visual)
+        {
+            lock (_lock)
+                _invalidated = true;
+            _renderer.AddDirty(visual);
+        }
+
+        public IEnumerable<IVisual> HitTest(Point p, IVisual root, Func<IVisual, bool> filter)
+        {
+            return _renderer.HitTest(p, root, filter);
+        }
+
+        public IVisual HitTestFirst(Point p, IVisual root, Func<IVisual, bool> filter)
+        {
+            return _renderer.HitTestFirst(p, root, filter);
+        }
+
+        public void RecalculateChildren(IVisual visual)
+        {
+            _renderer.RecalculateChildren(visual);
+        }
+
+        public void Resized(Size size)
+        {
+            _renderer.Resized(size);
+        }
+
+        public void Paint(Rect rect)
+        {
+            _invalidated = false;
+            _renderer.Paint(rect);
+        }
+
+        public void Start()
+        {
+            _loop.Add(this);
+            _renderer.Start();
+        }
+
+        public void Stop()
+        {
+            _loop.Remove(this);
+            _renderer.Stop();
+        }
+
+        public bool NeedsUpdate => false;
+        public void Update(TimeSpan time)
+        {
+            
+        }
+
+        public void Render()
+        {
+            if (_invalidated)
+            {
+                lock (_lock)
+                    _invalidated = false;
+                Dispatcher.UIThread.Post(() => Paint(new Rect(0, 0, 100000, 100000)));
+            }
+        }
+    }
+}
diff --git a/src/Avalonia.X11/X11Platform.cs b/src/Avalonia.X11/X11Platform.cs
index 8b531bd9c5..028c47c978 100644
--- a/src/Avalonia.X11/X11Platform.cs
+++ b/src/Avalonia.X11/X11Platform.cs
@@ -96,6 +96,7 @@ namespace Avalonia
         public bool UseGpu { get; set; } = true;
         public bool OverlayPopups { get; set; }
         public bool UseDBusMenu { get; set; }
+        public bool UseDeferredRendering { get; set; } = true;
 
         public List<string> GlxRendererBlacklist { get; set; } = new List<string>
         {
diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs
index 8419e7dab2..74f2606dc8 100644
--- a/src/Avalonia.X11/X11Window.cs
+++ b/src/Avalonia.X11/X11Window.cs
@@ -27,7 +27,6 @@ namespace Avalonia.X11
         private readonly IWindowImpl _popupParent;
         private readonly bool _popup;
         private readonly X11Info _x11;
-        private bool _invalidated;
         private XConfigureEvent? _configure;
         private PixelPoint? _configurePoint;
         private bool _triggeredExpose;
@@ -308,8 +307,13 @@ namespace Avalonia.X11
         public Action Closed { get; set; }
         public Action<PixelPoint> PositionChanged { get; set; }
 
-        public IRenderer CreateRenderer(IRenderRoot root) =>
-            new DeferredRenderer(root, AvaloniaLocator.Current.GetService<IRenderLoop>());
+        public IRenderer CreateRenderer(IRenderRoot root)
+        {
+            var loop = AvaloniaLocator.Current.GetService<IRenderLoop>();
+            return _platform.Options.UseDeferredRendering ?
+                new DeferredRenderer(root, loop) :
+                (IRenderer)new X11ImmediateRendererProxy(root, loop);
+        }
 
         void OnEvent(XEvent ev)
         {
@@ -683,20 +687,12 @@ namespace Avalonia.X11
 
         void DoPaint()
         {
-            _invalidated = false;
             Paint?.Invoke(new Rect());
         }
         
         public void Invalidate(Rect rect)
         {
-            if(_invalidated)
-                return;
-            _invalidated = true;
-            Dispatcher.UIThread.InvokeAsync(() =>
-            {
-                if (_mapped)
-                    DoPaint();
-            });
+
         }
 
         public IInputRoot InputRoot => _inputRoot;

From c16e377bc61b93ce8947b192d16d72bd5fd21daa Mon Sep 17 00:00:00 2001
From: Marcus Wichelmann <marcus.wichelmann@hotmail.de>
Date: Thu, 2 Apr 2020 16:08:38 +0200
Subject: [PATCH 15/29] Fix crash caused by window decorations not being
 available when using remote rendering

---
 samples/ControlCatalog/MainView.xaml.cs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/samples/ControlCatalog/MainView.xaml.cs b/samples/ControlCatalog/MainView.xaml.cs
index 5f71b2ecd9..7c17b125d6 100644
--- a/samples/ControlCatalog/MainView.xaml.cs
+++ b/samples/ControlCatalog/MainView.xaml.cs
@@ -60,8 +60,8 @@ namespace ControlCatalog
             var decorations = this.Find<ComboBox>("Decorations");
             decorations.SelectionChanged += (sender, e) =>
             {
-                Window window = (Window)VisualRoot;
-                window.SystemDecorations = (SystemDecorations)decorations.SelectedIndex;
+                if (VisualRoot is Window window)
+                    window.SystemDecorations = (SystemDecorations)decorations.SelectedIndex;
             };
         }
 
@@ -69,7 +69,8 @@ namespace ControlCatalog
         {
             base.OnAttachedToVisualTree(e);
             var decorations = this.Find<ComboBox>("Decorations");
-            decorations.SelectedIndex = (int)((Window)VisualRoot).SystemDecorations;
+            if (VisualRoot is Window window)
+                decorations.SelectedIndex = (int)window.SystemDecorations;
         }
     }
 }

From 92770765e3c3b72f3d7a06370d5f9a4b696ee1ef Mon Sep 17 00:00:00 2001
From: Marcus Wichelmann <marcus.wichelmann@hotmail.de>
Date: Thu, 2 Apr 2020 16:21:04 +0200
Subject: [PATCH 16/29] Fixed bitmaps not getting disposed correctly causing a
 memory leak in RemoteWidget

---
 src/Avalonia.Controls/Remote/RemoteWidget.cs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/Remote/RemoteWidget.cs b/src/Avalonia.Controls/Remote/RemoteWidget.cs
index c7a1a24c25..fabb38f87d 100644
--- a/src/Avalonia.Controls/Remote/RemoteWidget.cs
+++ b/src/Avalonia.Controls/Remote/RemoteWidget.cs
@@ -75,7 +75,11 @@ namespace Avalonia.Controls.Remote
                 var fmt = (PixelFormat) _lastFrame.Format;
                 if (_bitmap == null || _bitmap.PixelSize.Width != _lastFrame.Width ||
                     _bitmap.PixelSize.Height != _lastFrame.Height)
-                    _bitmap = new WriteableBitmap(new PixelSize(_lastFrame.Width, _lastFrame.Height), new Vector(96, 96), fmt);
+                {
+                    _bitmap?.Dispose();
+                    _bitmap = new WriteableBitmap(new PixelSize(_lastFrame.Width, _lastFrame.Height),
+                        new Vector(96, 96), fmt);
+                }
                 using (var l = _bitmap.Lock())
                 {
                     var lineLen = (fmt == PixelFormat.Rgb565 ? 2 : 4) * _lastFrame.Width;

From 58a20b610940dd559581dedf794578b185484098 Mon Sep 17 00:00:00 2001
From: Nikita Tsukanov <keks9n@gmail.com>
Date: Fri, 3 Apr 2020 17:23:06 +0300
Subject: [PATCH 17/29] [X11] Emulate synchronous resize/move events until
 window is mapped for the first time

---
 src/Avalonia.X11/X11Window.cs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.X11/X11Window.cs b/src/Avalonia.X11/X11Window.cs
index 8419e7dab2..a24042184c 100644
--- a/src/Avalonia.X11/X11Window.cs
+++ b/src/Avalonia.X11/X11Window.cs
@@ -41,6 +41,7 @@ namespace Avalonia.X11
         private IntPtr _xic;
         private IntPtr _renderHandle;
         private bool _mapped;
+        private bool _wasMappedAtLeastOnce = false;
         private HashSet<X11Window> _transientChildren = new HashSet<X11Window>();
         private X11Window _transientParent;
         private double? _scalingOverride;
@@ -769,6 +770,7 @@ namespace Avalonia.X11
         
         void ShowCore()
         {
+            _wasMappedAtLeastOnce = true;
             XMapWindow(_x11.Display, _handle);
             XFlush(_x11.Display);
         }
@@ -816,7 +818,7 @@ namespace Avalonia.X11
                 XConfigureResizeWindow(_x11.Display, _renderHandle, pixelSize);
             XFlush(_x11.Display);
 
-            if (force || (_popup && needImmediatePopupResize))
+            if (force || !_wasMappedAtLeastOnce || (_popup && needImmediatePopupResize))
             {
                 _realSize = pixelSize;
                 Resized?.Invoke(ClientSize);
@@ -857,6 +859,11 @@ namespace Avalonia.X11
                 XConfigureWindow(_x11.Display, _handle, ChangeWindowFlags.CWX | ChangeWindowFlags.CWY,
                     ref changes);
                 XFlush(_x11.Display);
+                if (!_wasMappedAtLeastOnce)
+                {
+                    _position = value;
+                    PositionChanged?.Invoke(value);
+                }
 
             }
         }

From 90e9dfa0b6e6c7d0d5c30f141e75a373464a1d6d Mon Sep 17 00:00:00 2001
From: Steve <hez2010@outlook.com>
Date: Fri, 3 Apr 2020 23:06:42 +0800
Subject: [PATCH 18/29] Update System.Reactive to 4.4.1 to avoid infinite
 recursive generics in CoreRT

---
 build/Rx.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build/Rx.props b/build/Rx.props
index edff0af160..8a15ccd6a9 100644
--- a/build/Rx.props
+++ b/build/Rx.props
@@ -1,5 +1,5 @@
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
-    <PackageReference Include="System.Reactive" Version="4.1.6" />
+    <PackageReference Include="System.Reactive" Version="4.4.1" />
   </ItemGroup>
 </Project>

From b0c79e30948db9020ed9c71e1d8dc6a2440c5ed4 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 3 Apr 2020 16:12:16 +0200
Subject: [PATCH 19/29] Added failing leak test for #3738.

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

diff --git a/tests/Avalonia.LeakTests/ControlTests.cs b/tests/Avalonia.LeakTests/ControlTests.cs
index 5cec5c134d..de3f0f8189 100644
--- a/tests/Avalonia.LeakTests/ControlTests.cs
+++ b/tests/Avalonia.LeakTests/ControlTests.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.Remoting.Contexts;
 using Avalonia.Controls;
 using Avalonia.Controls.Templates;
 using Avalonia.Diagnostics;
@@ -419,6 +420,37 @@ namespace Avalonia.LeakTests
             }
         }
 
+        [Fact]
+        public void Context_MenuItems_Are_Freed()
+        {
+            using (Start())
+            {
+                void BuildAndShowContextMenu(Control control)
+                {
+                    var contextMenu = new ContextMenu
+                    {
+                        Items = new[]
+                        {
+                            new MenuItem { Header = "Foo" },
+                            new MenuItem { Header = "Foo" },
+                        }
+                    };
+
+                    contextMenu.Open(control);
+                    contextMenu.Close();
+                }
+
+                var window = new Window();
+                BuildAndShowContextMenu(window);
+                BuildAndShowContextMenu(window);
+
+                dotMemory.Check(memory =>
+                    Assert.Equal(0, memory.GetObjects(where => where.Type.Is<ContextMenu>()).ObjectsCount));
+                dotMemory.Check(memory =>
+                    Assert.Equal(0, memory.GetObjects(where => where.Type.Is<MenuItem>()).ObjectsCount));
+            }
+        }
+
         private IDisposable Start()
         {
             return UnitTestApplication.Start(TestServices.StyledWindow);

From b42458be76891a08968f0c9fc516889a4e0dd24f Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 3 Apr 2020 23:19:42 +0200
Subject: [PATCH 20/29] Input manager subscription may be null.

As we accept a null `InputManager` for unit testing.
---
 src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs b/src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs
index bf811ad008..3715bc52a4 100644
--- a/src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs
+++ b/src/Avalonia.Controls/Platform/DefaultMenuInteractionHandler.cs
@@ -96,7 +96,7 @@ namespace Avalonia.Controls.Platform
                 root.Deactivated -= WindowDeactivated;
             }
 
-            _inputManagerSubscription!.Dispose();
+            _inputManagerSubscription?.Dispose();
 
             Menu = null;
             _root = null;

From 76b4d17abf0de768fc9504fc1b8ef9967466429c Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Fri, 3 Apr 2020 23:21:06 +0200
Subject: [PATCH 21/29] Remove ContextMenu from logical tree.

When the `ContextMenu` is not attached to a control, i.e. it is shown using `Show(control)` then we need to detach it from the logical tree once hidden otherwise it will leak, causing #3738.
---
 src/Avalonia.Controls/ContextMenu.cs | 41 ++++++++++++++--------------
 1 file changed, 21 insertions(+), 20 deletions(-)

diff --git a/src/Avalonia.Controls/ContextMenu.cs b/src/Avalonia.Controls/ContextMenu.cs
index fc56e26add..0ee906fb55 100644
--- a/src/Avalonia.Controls/ContextMenu.cs
+++ b/src/Avalonia.Controls/ContextMenu.cs
@@ -20,6 +20,7 @@ namespace Avalonia.Controls
         private static readonly ITemplate<IPanel> DefaultPanel =
             new FuncTemplate<IPanel>(() => new StackPanel { Orientation = Orientation.Vertical });
         private Popup _popup;
+        private bool _attachedToControl;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ContextMenu"/> class.
@@ -69,13 +70,15 @@ namespace Avalonia.Controls
         {
             var control = (Control)e.Sender;
 
-            if (e.OldValue != null)
+            if (e.OldValue is ContextMenu oldMenu)
             {
                 control.PointerReleased -= ControlPointerReleased;
+                oldMenu._attachedToControl = false;
             }
 
-            if (e.NewValue != null)
+            if (e.NewValue is ContextMenu newMenu)
             {
+                newMenu._attachedToControl = true;
                 control.PointerReleased += ControlPointerReleased;
             }
         }
@@ -145,18 +148,6 @@ namespace Avalonia.Controls
             return new MenuItemContainerGenerator(this);
         }
 
-        private void CloseCore()
-        {
-            SelectedIndex = -1;
-            IsOpen = false;
-
-            RaiseEvent(new RoutedEventArgs
-            {
-                RoutedEvent = MenuClosedEvent,
-                Source = this,
-            });
-        }
-
         private void PopupOpened(object sender, EventArgs e)
         {
             Focus();
@@ -164,17 +155,27 @@ namespace Avalonia.Controls
 
         private void PopupClosed(object sender, EventArgs e)
         {
-            var contextMenu = (sender as Popup)?.Child as ContextMenu;
-
-            if (contextMenu != null)
+            foreach (var i in LogicalChildren)
             {
-                foreach (var i in contextMenu.GetLogicalChildren().OfType<MenuItem>())
+                if (i is MenuItem menuItem)
                 {
-                    i.IsSubMenuOpen = false;
+                    menuItem.IsSubMenuOpen = false;
                 }
+            }
+
+            SelectedIndex = -1;
+            IsOpen = false;
 
-                contextMenu.CloseCore();
+            if (!_attachedToControl)
+            {
+                ((ISetLogicalParent)_popup).SetParent(null);
             }
+
+            RaiseEvent(new RoutedEventArgs
+            {
+                RoutedEvent = MenuClosedEvent,
+                Source = this,
+            });
         }
 
         private static void ControlPointerReleased(object sender, PointerReleasedEventArgs e)

From 323cfdca3a9014aa8ef2ded007c6031350477a46 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Sat, 4 Apr 2020 00:23:45 +0200
Subject: [PATCH 22/29] Make ContextMenu leak tests fail again.

By adding focus/input manager.
---
 src/Avalonia.Controls/WindowBase.cs               |  2 +-
 tests/Avalonia.LeakTests/ControlTests.cs          | 10 +++++++++-
 tests/Avalonia.UnitTests/MockWindowingPlatform.cs |  4 ++++
 3 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/Avalonia.Controls/WindowBase.cs b/src/Avalonia.Controls/WindowBase.cs
index 196110edf7..63eabb32f4 100644
--- a/src/Avalonia.Controls/WindowBase.cs
+++ b/src/Avalonia.Controls/WindowBase.cs
@@ -255,7 +255,7 @@ namespace Avalonia.Controls
 
             if (scope != null)
             {
-                FocusManager.Instance.SetFocusScope(scope);
+                FocusManager.Instance?.SetFocusScope(scope);
             }
 
             IsActive = true;
diff --git a/tests/Avalonia.LeakTests/ControlTests.cs b/tests/Avalonia.LeakTests/ControlTests.cs
index de3f0f8189..f93b763738 100644
--- a/tests/Avalonia.LeakTests/ControlTests.cs
+++ b/tests/Avalonia.LeakTests/ControlTests.cs
@@ -5,6 +5,7 @@ using System.Runtime.Remoting.Contexts;
 using Avalonia.Controls;
 using Avalonia.Controls.Templates;
 using Avalonia.Diagnostics;
+using Avalonia.Input;
 using Avalonia.Layout;
 using Avalonia.Media;
 using Avalonia.Platform;
@@ -441,6 +442,10 @@ namespace Avalonia.LeakTests
                 }
 
                 var window = new Window();
+                window.Show();
+
+                Assert.Same(window, FocusManager.Instance.Current);
+
                 BuildAndShowContextMenu(window);
                 BuildAndShowContextMenu(window);
 
@@ -453,7 +458,10 @@ namespace Avalonia.LeakTests
 
         private IDisposable Start()
         {
-            return UnitTestApplication.Start(TestServices.StyledWindow);
+            return UnitTestApplication.Start(TestServices.StyledWindow.With(
+                focusManager: new FocusManager(),
+                keyboardDevice: () => new KeyboardDevice(),
+                inputManager: new InputManager()));
         }
 
         private class Node
diff --git a/tests/Avalonia.UnitTests/MockWindowingPlatform.cs b/tests/Avalonia.UnitTests/MockWindowingPlatform.cs
index a6701ef655..782e4a0974 100644
--- a/tests/Avalonia.UnitTests/MockWindowingPlatform.cs
+++ b/tests/Avalonia.UnitTests/MockWindowingPlatform.cs
@@ -21,6 +21,10 @@ namespace Avalonia.UnitTests
         {
             var win = Mock.Of<IWindowImpl>(x => x.Scaling == 1);
             var mock = Mock.Get(win);
+            mock.Setup(x => x.Show()).Callback(() =>
+            {
+                mock.Object.Activated?.Invoke();
+            });
             mock.Setup(x => x.CreatePopup()).Returns(() =>
             {
                 if (popupImpl != null)

From 1cb7d830c78c50385cdc4130cdec4d68b91bb99d Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Sat, 4 Apr 2020 00:32:08 +0200
Subject: [PATCH 23/29] Hack to reset focus when context menu closed.

Including a fix to `FocusManager` to ensure that it doesn't try to set focus to an invisble focus scope. Fixes #3738.
---
 src/Avalonia.Controls/ContextMenu.cs | 5 +++++
 src/Avalonia.Input/FocusManager.cs   | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/Avalonia.Controls/ContextMenu.cs b/src/Avalonia.Controls/ContextMenu.cs
index 0ee906fb55..61e4b69c9b 100644
--- a/src/Avalonia.Controls/ContextMenu.cs
+++ b/src/Avalonia.Controls/ContextMenu.cs
@@ -21,6 +21,7 @@ namespace Avalonia.Controls
             new FuncTemplate<IPanel>(() => new StackPanel { Orientation = Orientation.Vertical });
         private Popup _popup;
         private bool _attachedToControl;
+        private IInputElement _previousFocus;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ContextMenu"/> class.
@@ -150,6 +151,7 @@ namespace Avalonia.Controls
 
         private void PopupOpened(object sender, EventArgs e)
         {
+            _previousFocus = FocusManager.Instance?.Current;
             Focus();
         }
 
@@ -171,6 +173,9 @@ namespace Avalonia.Controls
                 ((ISetLogicalParent)_popup).SetParent(null);
             }
 
+            // HACK: Reset the focus when the popup is closed. We need to fix this so it's automatic.
+            FocusManager.Instance?.Focus(_previousFocus);
+
             RaiseEvent(new RoutedEventArgs
             {
                 RoutedEvent = MenuClosedEvent,
diff --git a/src/Avalonia.Input/FocusManager.cs b/src/Avalonia.Input/FocusManager.cs
index 500677c545..bcae8a3c53 100644
--- a/src/Avalonia.Input/FocusManager.cs
+++ b/src/Avalonia.Input/FocusManager.cs
@@ -168,7 +168,7 @@ namespace Avalonia.Input
             {
                 var scope = control as IFocusScope;
 
-                if (scope != null)
+                if (scope != null && control.VisualRoot?.IsVisible == true)
                 {
                     yield return scope;
                 }

From c4da0f75b805a3c9aa6c7dfc78c2c7ea95077678 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Sat, 4 Apr 2020 19:41:54 +0200
Subject: [PATCH 24/29] Added another failing ContextMenu leak test.

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

diff --git a/tests/Avalonia.LeakTests/ControlTests.cs b/tests/Avalonia.LeakTests/ControlTests.cs
index f93b763738..0afb2465ee 100644
--- a/tests/Avalonia.LeakTests/ControlTests.cs
+++ b/tests/Avalonia.LeakTests/ControlTests.cs
@@ -422,7 +422,43 @@ namespace Avalonia.LeakTests
         }
 
         [Fact]
-        public void Context_MenuItems_Are_Freed()
+        public void Attached_ContextMenu_Is_Freed()
+        {
+            using (Start())
+            {
+                void AttachShowAndDetachContextMenu(Control control)
+                {
+                    var contextMenu = new ContextMenu
+                    {
+                        Items = new[]
+                        {
+                            new MenuItem { Header = "Foo" },
+                            new MenuItem { Header = "Foo" },
+                        }
+                    };
+
+                    control.ContextMenu = contextMenu;
+                    contextMenu.Open(control);
+                    contextMenu.Close();
+                    control.ContextMenu = null;
+                }
+
+                var window = new Window();
+                window.Show();
+
+                Assert.Same(window, FocusManager.Instance.Current);
+
+                AttachShowAndDetachContextMenu(window);
+
+                dotMemory.Check(memory =>
+                    Assert.Equal(0, memory.GetObjects(where => where.Type.Is<ContextMenu>()).ObjectsCount));
+                dotMemory.Check(memory =>
+                    Assert.Equal(0, memory.GetObjects(where => where.Type.Is<MenuItem>()).ObjectsCount));
+            }
+        }
+
+        [Fact]
+        public void Standalone_ContextMenu_Is_Freed()
         {
             using (Start())
             {

From c4433369281c6aaed7d2b7278dc07f5fb76764bc Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Sat, 4 Apr 2020 19:48:06 +0200
Subject: [PATCH 25/29] Fix leaks in attached context menu,

---
 src/Avalonia.Controls/ContextMenu.cs | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/src/Avalonia.Controls/ContextMenu.cs b/src/Avalonia.Controls/ContextMenu.cs
index 61e4b69c9b..bb9b853c28 100644
--- a/src/Avalonia.Controls/ContextMenu.cs
+++ b/src/Avalonia.Controls/ContextMenu.cs
@@ -20,7 +20,7 @@ namespace Avalonia.Controls
         private static readonly ITemplate<IPanel> DefaultPanel =
             new FuncTemplate<IPanel>(() => new StackPanel { Orientation = Orientation.Vertical });
         private Popup _popup;
-        private bool _attachedToControl;
+        private Control _attachedControl;
         private IInputElement _previousFocus;
 
         /// <summary>
@@ -74,12 +74,13 @@ namespace Avalonia.Controls
             if (e.OldValue is ContextMenu oldMenu)
             {
                 control.PointerReleased -= ControlPointerReleased;
-                oldMenu._attachedToControl = false;
+                oldMenu._attachedControl = null;
+                ((ISetLogicalParent)oldMenu._popup).SetParent(null);
             }
 
             if (e.NewValue is ContextMenu newMenu)
             {
-                newMenu._attachedToControl = true;
+                newMenu._attachedControl = control;
                 control.PointerReleased += ControlPointerReleased;
             }
         }
@@ -95,8 +96,18 @@ namespace Avalonia.Controls
         /// <param name="control">The control.</param>
         public void Open(Control control)
         {
-            if (control == null)
+            if (control is null && _attachedControl is null)
+            {
                 throw new ArgumentNullException(nameof(control));
+            }
+
+            if (control is object && _attachedControl is object && control != _attachedControl)
+            {
+                throw new ArgumentException(
+                    "Cannot show ContentMenu on a different control to the one it is attached to.",
+                    nameof(control));
+            }
+
             if (IsOpen)
             {
                 return;
@@ -168,7 +179,7 @@ namespace Avalonia.Controls
             SelectedIndex = -1;
             IsOpen = false;
 
-            if (!_attachedToControl)
+            if (_attachedControl is null)
             {
                 ((ISetLogicalParent)_popup).SetParent(null);
             }

From bc36330bc01615bcfc99736ee6d5a2ed1affaef3 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Sun, 5 Apr 2020 17:19:37 +0200
Subject: [PATCH 26/29] Added failing ContextMenu test.

Due to NRE introduced in #3745.
---
 .../ContextMenuTests.cs                         | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/tests/Avalonia.Controls.UnitTests/ContextMenuTests.cs b/tests/Avalonia.Controls.UnitTests/ContextMenuTests.cs
index f44f89e91f..5a47a86e51 100644
--- a/tests/Avalonia.Controls.UnitTests/ContextMenuTests.cs
+++ b/tests/Avalonia.Controls.UnitTests/ContextMenuTests.cs
@@ -1,9 +1,5 @@
 using System;
-using System.Windows.Input;
-using Avalonia.Controls.Primitives;
-using Avalonia.Data;
 using Avalonia.Input;
-using Avalonia.Markup.Data;
 using Avalonia.Platform;
 using Avalonia.UnitTests;
 using Moq;
@@ -159,6 +155,19 @@ namespace Avalonia.Controls.UnitTests
             }
         }
 
+        [Fact]
+        public void Can_Set_Clear_ContextMenu_Property()
+        {
+            using (Application())
+            {
+                var target = new ContextMenu();
+                var control = new Panel();
+
+                control.ContextMenu = target;
+                control.ContextMenu = null;
+            }
+        }
+
         [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 5ad8c41f37a593f0d3861e5308fb45201f96fa4f Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Sun, 5 Apr 2020 17:19:58 +0200
Subject: [PATCH 27/29] Fix NRE in ContextMenu.

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

diff --git a/src/Avalonia.Controls/ContextMenu.cs b/src/Avalonia.Controls/ContextMenu.cs
index bb9b853c28..1735599988 100644
--- a/src/Avalonia.Controls/ContextMenu.cs
+++ b/src/Avalonia.Controls/ContextMenu.cs
@@ -75,7 +75,7 @@ namespace Avalonia.Controls
             {
                 control.PointerReleased -= ControlPointerReleased;
                 oldMenu._attachedControl = null;
-                ((ISetLogicalParent)oldMenu._popup).SetParent(null);
+                ((ISetLogicalParent)oldMenu._popup)?.SetParent(null);
             }
 
             if (e.NewValue is ContextMenu newMenu)

From 9adbe33577402e24207dce89e81b5cfbf05771a9 Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Mon, 6 Apr 2020 18:53:12 +0200
Subject: [PATCH 28/29] Added failing test for #2755.

---
 tests/Avalonia.Visuals.UnitTests/Media/BrushTests.cs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/tests/Avalonia.Visuals.UnitTests/Media/BrushTests.cs b/tests/Avalonia.Visuals.UnitTests/Media/BrushTests.cs
index 1ef8f1f29a..1a2f7732dd 100644
--- a/tests/Avalonia.Visuals.UnitTests/Media/BrushTests.cs
+++ b/tests/Avalonia.Visuals.UnitTests/Media/BrushTests.cs
@@ -77,5 +77,17 @@ namespace Avalonia.Visuals.UnitTests.Media
         {
             Assert.Throws<FormatException>(() => Brush.Parse("#ff808g80"));
         }
+
+        [Fact]
+        public void Changing_Opacity_Raises_Invalidated()
+        {
+            var target = new SolidColorBrush();
+            var raised = false;
+
+            target.Invalidated += (s, e) => raised = true;
+            target.Opacity = 0.5;
+
+            Assert.True(raised);
+        }
     }
 }

From 3fc21f30b4b3ce57bee74832b9185b47bc8fbe2f Mon Sep 17 00:00:00 2001
From: Steven Kirk <grokys@gmail.com>
Date: Mon, 6 Apr 2020 18:55:27 +0200
Subject: [PATCH 29/29] Invalidate brush when Opacity changes.

Fixes #2755.
---
 src/Avalonia.Visuals/Media/Brush.cs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/Avalonia.Visuals/Media/Brush.cs b/src/Avalonia.Visuals/Media/Brush.cs
index d4894e0d14..a19d5af8b7 100644
--- a/src/Avalonia.Visuals/Media/Brush.cs
+++ b/src/Avalonia.Visuals/Media/Brush.cs
@@ -19,6 +19,11 @@ namespace Avalonia.Media
         /// <inheritdoc/>
         public event EventHandler Invalidated;
 
+        static Brush()
+        {
+            AffectsRender<Brush>(OpacityProperty);
+        }
+
         /// <summary>
         /// Gets or sets the opacity of the brush.
         /// </summary>