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>
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;
         }
     }
 }
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..ba68b113e3 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
@@ -61,14 +62,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.Base/Data/Converters/FuncMultiValueConverter.cs b/src/Avalonia.Base/Data/Converters/FuncMultiValueConverter.cs
index 38c8e123cd..988cc123f9 100644
--- a/src/Avalonia.Base/Data/Converters/FuncMultiValueConverter.cs
+++ b/src/Avalonia.Base/Data/Converters/FuncMultiValueConverter.cs
@@ -27,7 +27,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)
             {
diff --git a/src/Avalonia.Controls/ContextMenu.cs b/src/Avalonia.Controls/ContextMenu.cs
index fc56e26add..1735599988 100644
--- a/src/Avalonia.Controls/ContextMenu.cs
+++ b/src/Avalonia.Controls/ContextMenu.cs
@@ -20,6 +20,8 @@ namespace Avalonia.Controls
         private static readonly ITemplate<IPanel> DefaultPanel =
             new FuncTemplate<IPanel>(() => new StackPanel { Orientation = Orientation.Vertical });
         private Popup _popup;
+        private Control _attachedControl;
+        private IInputElement _previousFocus;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ContextMenu"/> class.
@@ -69,13 +71,16 @@ namespace Avalonia.Controls
         {
             var control = (Control)e.Sender;
 
-            if (e.OldValue != null)
+            if (e.OldValue is ContextMenu oldMenu)
             {
                 control.PointerReleased -= ControlPointerReleased;
+                oldMenu._attachedControl = null;
+                ((ISetLogicalParent)oldMenu._popup)?.SetParent(null);
             }
 
-            if (e.NewValue != null)
+            if (e.NewValue is ContextMenu newMenu)
             {
+                newMenu._attachedControl = control;
                 control.PointerReleased += ControlPointerReleased;
             }
         }
@@ -91,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;
@@ -145,36 +160,38 @@ 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)
         {
+            _previousFocus = FocusManager.Instance?.Current;
             Focus();
         }
 
         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;
                 }
+            }
 
-                contextMenu.CloseCore();
+            SelectedIndex = -1;
+            IsOpen = false;
+
+            if (_attachedControl is null)
+            {
+                ((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,
+                Source = this,
+            });
         }
 
         private static void ControlPointerReleased(object sender, PointerReleasedEventArgs e)
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;
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;
diff --git a/src/Avalonia.Controls/Window.cs b/src/Avalonia.Controls/Window.cs
index 7c05be9edb..387bf0adb8 100644
--- a/src/Avalonia.Controls/Window.cs
+++ b/src/Avalonia.Controls/Window.cs
@@ -186,6 +186,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/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/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;
                 }
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>
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;
         }
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..60fd0346a3 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;
@@ -41,6 +40,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;
@@ -308,8 +308,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 +688,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;
@@ -758,7 +755,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()
@@ -769,6 +774,7 @@ namespace Avalonia.X11
         
         void ShowCore()
         {
+            _wasMappedAtLeastOnce = true;
             XMapWindow(_x11.Display, _handle);
             XFlush(_x11.Display);
         }
@@ -816,7 +822,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 +863,11 @@ namespace Avalonia.X11
                 XConfigureWindow(_x11.Display, _handle, ChangeWindowFlags.CWX | ChangeWindowFlags.CWY,
                     ref changes);
                 XFlush(_x11.Display);
+                if (!_wasMappedAtLeastOnce)
+                {
+                    _position = value;
+                    PositionChanged?.Invoke(value);
+                }
 
             }
         }
diff --git a/src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs b/src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs
new file mode 100644
index 0000000000..3ea8c1e48f
--- /dev/null
+++ b/src/Windows/Avalonia.Win32/WindowImpl.WndProc.cs
@@ -0,0 +1,527 @@
+// 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)((int)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())
+                    {
+                        if (BeginPaint(_hwnd, out PAINTSTRUCT 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;
+            }
+
+            // 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;
+        }
+
+        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 da98712c8b..e193c72ef7 100644
--- a/src/Windows/Avalonia.Win32/WindowImpl.cs
+++ b/src/Windows/Avalonia.Win32/WindowImpl.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
-using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
 using Avalonia.Controls;
 using Avalonia.Input;
@@ -15,43 +14,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 =>
             {
@@ -61,11 +79,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);
         }
@@ -94,14 +125,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);
                     }
@@ -117,16 +148,88 @@ namespace Avalonia.Win32
             }
         }
 
+        public double Scaling => _scaling;
+
         public Size ClientSize
         {
             get
             {
-                UnmanagedMethods.RECT rect;
-                UnmanagedMethods.GetClientRect(_hwnd, out rect);
+                GetClientRect(_hwnd, out var rect);
+
                 return new Size(rect.right, rect.bottom) / Scaling;
             }
         }
 
+        public IScreenImpl Screen { get; }
+
+        public IPlatformHandle Handle { get; private set; }
+
+        public Size MaxClientSize
+        {
+            get
+            {
+                return (new Size(
+                            GetSystemMetrics(SystemMetric.SM_CXMAXTRACK),
+                            GetSystemMetrics(SystemMetric.SM_CYMAXTRACK))
+                        - BorderThickness) / Scaling;
+            }
+        }
+
+        public IMouseDevice MouseDevice => _mouseDevice;
+
+        public WindowState WindowState
+        {
+            get
+            {
+                var placement = default(WINDOWPLACEMENT);
+                GetWindowPlacement(_hwnd, ref placement);
+
+                return placement.ShowCmd switch
+                {
+                    ShowWindowCommand.Maximize => WindowState.Maximized,
+                    ShowWindowCommand.Minimize => WindowState.Minimized,
+                    _ => WindowState.Normal
+                };
+            }
+
+            set
+            {
+                if (IsWindowVisible(_hwnd))
+                {
+                    ShowWindow(value);
+                }
+                else
+                {
+                    _showWindowState = value;
+                }
+            }
+        }
+
+        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)
@@ -135,12 +238,6 @@ namespace Avalonia.Win32
             _maxSize = maxSize;
         }
 
-        public IScreenImpl Screen
-        {
-            get;
-        } = new ScreenImpl();
-
-
         public IRenderer CreateRenderer(IRenderRoot root)
         {
             var loop = AvaloniaLocator.Current.GetService<IRenderLoop>();
@@ -158,92 +255,28 @@ namespace Avalonia.Win32
         {
             int requestedClientWidth = (int)(value.Width * Scaling);
             int requestedClientHeight = (int)(value.Height * Scaling);
-            UnmanagedMethods.RECT clientRect;
-            UnmanagedMethods.GetClientRect(_hwnd, out clientRect);
-           
+
+            GetClientRect(_hwnd, out var clientRect);
+
             // do comparison after scaling to avoid rounding issues
             if (requestedClientWidth != clientRect.Width || requestedClientHeight != clientRect.Height)
             {
-                UnmanagedMethods.RECT windowRect;
-                UnmanagedMethods.GetWindowRect(_hwnd, out windowRect);
+                GetWindowRect(_hwnd, out var windowRect);
 
-                UnmanagedMethods.SetWindowPos(
+                SetWindowPos(
                     _hwnd,
                     IntPtr.Zero,
                     0,
                     0,
                     requestedClientWidth + (windowRect.Width - clientRect.Width),
                     requestedClientHeight + (windowRect.Height - clientRect.Height),
-                    UnmanagedMethods.SetWindowPosFlags.SWP_RESIZE);
-            }
-        }
-
-        public double Scaling => _scaling;
-
-        public IPlatformHandle Handle
-        {
-            get;
-            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;
-            }
-        }
-
-        public IMouseDevice MouseDevice => _mouseDevice;
-
-        public WindowState WindowState
-        {
-            get
-            {
-                var placement = default(UnmanagedMethods.WINDOWPLACEMENT);
-                UnmanagedMethods.GetWindowPlacement(_hwnd, ref placement);
-
-                switch (placement.ShowCmd)
-                {
-                    case UnmanagedMethods.ShowWindowCommand.Maximize:
-                        return WindowState.Maximized;
-                    case UnmanagedMethods.ShowWindowCommand.Minimize:
-                        return WindowState.Minimized;
-                    default:
-                        return WindowState.Normal;
-                }
-            }
-
-            set
-            {
-                if (UnmanagedMethods.IsWindowVisible(_hwnd))
-                {
-                    ShowWindow(value);
-                }
-                else
-                {
-                    _showWindowState = value;
-                }
+                    SetWindowPosFlags.SWP_RESIZE);
             }
         }
 
-        public IEnumerable<object> Surfaces => new object[]
-        {
-            Handle, _gl, _framebuffer
-        };
-
         public void Activate()
         {
-            UnmanagedMethods.SetActiveWindow(_hwnd);
+            SetActiveWindow(_hwnd);
         }
 
         public IPopupImpl CreatePopup() => Win32Platform.UseOverlayPopups ? null : new PopupImpl(this);
@@ -255,56 +288,37 @@ 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;
-            }
-
-            UpdateWMStyles(()=> _decorated = value);
-        }
-
         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;
         }
@@ -312,8 +326,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);
         }
 
@@ -323,9 +337,16 @@ namespace Avalonia.Win32
             CreateDropTarget();
         }
 
-        public void SetTitle(string title)
+        public void Hide()
         {
-            UnmanagedMethods.SetWindowText(_hwnd, title);
+            if (_parent != null)
+            {
+                _parent._disabledBy.Remove(this);
+                _parent.UpdateEnabled();
+                _parent = null;
+            }
+
+            UnmanagedMethods.ShowWindow(_hwnd, ShowWindowCommand.Hide);
         }
 
         public virtual void Show()
@@ -334,490 +355,140 @@ 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));
+            _managedDrag.BeginResizeDrag(edge, ScreenToClient(MouseDevice.Position.ToPoint(_scaling)));
 #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)
+        public void SetTitle(string title)
         {
-            _parent = (WindowImpl)parent;
-            _parent._disabledBy.Add(this);
-            _parent.UpdateEnabled();
-            SetWindowLongPtr(_hwnd, (int)WindowLongParam.GWL_HWNDPARENT, ((WindowImpl)parent)._hwnd);
-            ShowWindow(_showWindowState);
+            SetWindowText(_hwnd, title);
         }
 
         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);
+            }
         }
 
-        protected virtual IntPtr CreateWindowOverride(ushort atom)
+        public void SetIcon(IWindowIconImpl icon)
         {
-            return UnmanagedMethods.CreateWindowEx(
-                0,
-                atom,
-                null,
-                (int)UnmanagedMethods.WindowStyles.WS_OVERLAPPEDWINDOW,
-                UnmanagedMethods.CW_USEDEFAULT,
-                UnmanagedMethods.CW_USEDEFAULT,
-                UnmanagedMethods.CW_USEDEFAULT,
-                UnmanagedMethods.CW_USEDEFAULT,
-                IntPtr.Zero,
-                IntPtr.Zero,
-                IntPtr.Zero,
-                IntPtr.Zero);
+            var impl = (IconImpl)icon;
+            var hIcon = impl?.HIcon ?? IntPtr.Zero;
+            PostMessage(_hwnd, (int)WindowsMessage.WM_SETICON,
+                new IntPtr((int)Icons.ICON_BIG), hIcon);
         }
 
-        bool ShouldIgnoreTouchEmulatedMessage()
-        {
-            if (!_multitouch)
-                return false;
-            var marker = 0xFF515700L;
-            var info = GetMessageExtraInfo().ToInt64();
-            return (info & marker) == marker;
-        }
-        
-        [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)
+        public void ShowTaskbarIcon(bool value)
         {
-            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;
+            var newWindowProperties = _windowProperties;
 
-                case UnmanagedMethods.WindowsMessage.WM_CLOSE:
-                    bool? preventClosing = Closing?.Invoke();
-                    if (preventClosing == true)
-                    {
-                        return IntPtr.Zero;
-                    }
-                    break;
+            newWindowProperties.ShowInTaskbar = value;
 
-                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);
+            UpdateWindowProperties(newWindowProperties);
+        }
 
-                    if (!Double.IsInfinity(_maxSize.Width) && _maxSize.Width > 0)
-                        mmi.ptMaxTrackSize.X = (int)((_maxSize.Width * Scaling) + BorderThickness.Left + BorderThickness.Right);
+        public void CanResize(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.IsResizable = 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 SetSystemDecorations(SystemDecorations value)
+        {
+            var newWindowProperties = _windowProperties;
 
-#if USE_MANAGED_DRAG
+            newWindowProperties.Decorations = 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);
+
+            _topmost = value;
         }
 
-        static RawInputModifiers GetMouseModifiers(IntPtr wParam)
+        protected virtual IntPtr CreateWindowOverride(ushort atom)
         {
-            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;
+            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.
-            _wndProcDelegate = new UnmanagedMethods.WndProc(WndProc);
+            _wndProcDelegate = WndProc;
 
             _className = $"Avalonia-{Guid.NewGuid().ToString()}";
 
-            UnmanagedMethods.WNDCLASSEX wndClassEx = new UnmanagedMethods.WNDCLASSEX
+            // 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<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)windowClassStyle,
                 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)
             {
@@ -834,22 +505,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;
                 }
@@ -858,31 +530,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)
             {
@@ -920,12 +578,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);
@@ -936,149 +592,132 @@ 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);
+            // Calling SetWindowPos will cause events to be sent and we need to respond
+            // according to the new values already.
+            _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;
+                }
 
-            change();
+                SetStyle(style);
+            }
 
-            var style = (WindowStyles)GetWindowLong(_hwnd, (int)WindowLongParam.GWL_STYLE);
+            if (oldProperties.Decorations != newProperties.Decorations)
+            {
+                var style = GetStyle();
 
-            const WindowStyles controlledFlags = WindowStyles.WS_OVERLAPPEDWINDOW;
+                const WindowStyles fullDecorationFlags = WindowStyles.WS_CAPTION | WindowStyles.WS_SYSMENU;
 
-            style = style | controlledFlags ^ controlledFlags;
+                if (newProperties.Decorations == SystemDecorations.Full)
+                {
+                    style |= fullDecorationFlags;
+                }
+                else
+                {
+                    style &= ~fullDecorationFlags;
+                }
 
-            style |= WindowStyles.WS_OVERLAPPEDWINDOW;
+                var margins = new MARGINS
+                {
+                    cyBottomHeight = newProperties.Decorations == SystemDecorations.BorderOnly ? 1 : 0
+                };
 
-            if (_decorated != SystemDecorations.Full)
-            {
-                style ^= (WindowStyles.WS_CAPTION | WindowStyles.WS_SYSMENU);
-            }
+                DwmExtendFrameIntoClientArea(_hwnd, ref margins);
 
-            if (!_resizable)
-            {
-                style ^= (WindowStyles.WS_SIZEFRAME);
-            }
+                GetClientRect(_hwnd, out var oldClientRect);
+                var oldClientRectOrigin = new POINT();
+                ClientToScreen(_hwnd, ref oldClientRectOrigin);
+                oldClientRect.Offset(oldClientRectOrigin);
+
+                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;
+        }
     }
 }
diff --git a/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
new file mode 100644
index 0000000000..757160a0a4
--- /dev/null
+++ b/tests/Avalonia.Base.UnitTests/AvaloniaObjectTests_MultiBinding.cs
@@ -0,0 +1,178 @@
+// 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);
+        }
+
+        [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);
+        }
+
+        [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);
+        }
+
+        [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);
+        }
+
+        [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
+        {
+            public static readonly StyledProperty<string> FooProperty =
+                AvaloniaProperty.Register<Class1, string>("Foo");
+
+            public string Foo
+            {
+                get => GetValue(FooProperty);
+                set => SetValue(FooProperty, value);
+            }
+        }
+    }
+}
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()
         {
diff --git a/tests/Avalonia.LeakTests/ControlTests.cs b/tests/Avalonia.LeakTests/ControlTests.cs
index 5cec5c134d..0afb2465ee 100644
--- a/tests/Avalonia.LeakTests/ControlTests.cs
+++ b/tests/Avalonia.LeakTests/ControlTests.cs
@@ -1,9 +1,11 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+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;
@@ -419,9 +421,83 @@ namespace Avalonia.LeakTests
             }
         }
 
+        [Fact]
+        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())
+            {
+                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();
+                window.Show();
+
+                Assert.Same(window, FocusManager.Instance.Current);
+
+                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);
+            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)
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);
+        }
     }
 }