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 6f5e503fb3..ba68b113e3 100644
--- a/samples/ControlCatalog/Pages/DialogsPage.xaml.cs
+++ b/samples/ControlCatalog/Pages/DialogsPage.xaml.cs
@@ -62,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.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/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;
+        }
     }
 }