From def0b0098b9f30c3f2f383c92e2f90ab1475c259 Mon Sep 17 00:00:00 2001
From: Sebastian Mayer <sebastian.mayer@trumpf.com>
Date: Mon, 30 Jan 2023 16:30:26 +0100
Subject: [PATCH 1/2] Squashed commit of the following:

commit b2018c1424e00b8597e50d416f8ea3e04caa896d
Author: Sebastian Mayer <sebastian.mayer@trumpf.com>
Date:   Mon Jan 30 16:20:14 2023 +0100

    Merge branch 'feat/add-wpf-offscreen-browser'
---
 CefSharp.Dom                                  |    2 +-
 .../BrowserProcessHandler.cs                  |   96 +-
 .../CefSharp.WPF.Internals/RectStruct.cs      |   48 +
 ...OffscreenOutOfProcessChromiumWebBrowser.cs |  119 ++
 .../OutOfProcessChromiumWebBrowser.cs         |   26 +-
 .../Program.cs                                |    6 +-
 .../RenderHandler.cs                          |   68 +
 CefSharp.OutOfProcess.Core/CefEventFlags.cs   |   40 +
 .../IChromiumWebBrowser.cs                    |    2 +-
 .../Internal/IRenderHandlerInternal.cs        |   13 +
 CefSharp.OutOfProcess.Core/MouseButtonType.cs |   25 +
 .../OutOfProcessConnectionTransport.cs        |    3 +-
 .../OutOfProcessHost.cs                       |   95 +-
 .../IOutOfProcessClientRpc.cs                 |   24 +-
 .../IOutOfProcessHostRpc.cs                   |   10 +-
 CefSharp.OutOfProcess.Interface/Rect.cs       |   51 +
 .../App.config                                |    6 +
 .../App.xaml                                  |   11 +
 .../App.xaml.cs                               |   16 +
 .../AssemblyInfo.cs                           |   14 +
 .../Behaviours/HoverLinkBehaviour.cs          |   34 +
 .../TextBoxBindingUpdateOnEnterBehaviour.cs   |   28 +
 ...OfProcess.Wpf.OffscreenHost.Example.csproj |   18 +
 .../Converter/EnvironmentConverter.cs         |   19 +
 .../Converter/TitleConverter.cs               |   19 +
 .../MainWindow.xaml                           |   85 ++
 .../MainWindow.xaml.cs                        |   52 +
 .../app.manifest                              |   77 ++
 ...harp.OutOfProcess.Wpf.OffscreenHost.csproj |   26 +
 .../CefSharpWPF/AbstractRenderHandler.cs      |  129 ++
 .../DirectWritableBitmapRenderHandler.cs      |  132 ++
 .../CefSharpWPF/NativeMethodWrapper.cs        |   32 +
 .../CefSharpWPF/RectStruct.cs                 |   47 +
 .../CefSharpWPF/WPFExtensions.cs              |  244 ++++
 .../WritableBitmapRenderHandler.cs            |  150 +++
 .../Internals/DelegateCommand.cs              |   68 +
 .../OffscreenChromiumWebBrowser.cs            | 1182 +++++++++++++++++
 CefSharp.OutOfProcess.sln                     |  146 +-
 38 files changed, 3018 insertions(+), 145 deletions(-)
 create mode 100644 CefSharp.OutOfProcess.BrowserProcess/CefSharp.WPF.Internals/RectStruct.cs
 create mode 100644 CefSharp.OutOfProcess.BrowserProcess/OffscreenOutOfProcessChromiumWebBrowser.cs
 create mode 100644 CefSharp.OutOfProcess.BrowserProcess/RenderHandler.cs
 create mode 100644 CefSharp.OutOfProcess.Core/CefEventFlags.cs
 create mode 100644 CefSharp.OutOfProcess.Core/Internal/IRenderHandlerInternal.cs
 create mode 100644 CefSharp.OutOfProcess.Core/MouseButtonType.cs
 create mode 100644 CefSharp.OutOfProcess.Interface/Rect.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/App.config
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/App.xaml
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/App.xaml.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/AssemblyInfo.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Behaviours/HoverLinkBehaviour.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Behaviours/TextBoxBindingUpdateOnEnterBehaviour.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.csproj
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Converter/EnvironmentConverter.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Converter/TitleConverter.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/MainWindow.xaml
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/MainWindow.xaml.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/app.manifest
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharp.OutOfProcess.Wpf.OffscreenHost.csproj
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/AbstractRenderHandler.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/DirectWritableBitmapRenderHandler.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/NativeMethodWrapper.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/RectStruct.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/WPFExtensions.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/WritableBitmapRenderHandler.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost/Internals/DelegateCommand.cs
 create mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost/OffscreenChromiumWebBrowser.cs

diff --git a/CefSharp.Dom b/CefSharp.Dom
index 97f3959..4a1d718 160000
--- a/CefSharp.Dom
+++ b/CefSharp.Dom
@@ -1 +1 @@
-Subproject commit 97f39597a889c61b3177e70dd1aef832f2c8065b
+Subproject commit 4a1d7189ad83161c4d63265077f15cc8dcd5f72b
diff --git a/CefSharp.OutOfProcess.BrowserProcess/BrowserProcessHandler.cs b/CefSharp.OutOfProcess.BrowserProcess/BrowserProcessHandler.cs
index eb35359..ae12dbb 100644
--- a/CefSharp.OutOfProcess.BrowserProcess/BrowserProcessHandler.cs
+++ b/CefSharp.OutOfProcess.BrowserProcess/BrowserProcessHandler.cs
@@ -1,4 +1,4 @@
-using CefSharp.Internals;
+using CefSharp.Internals;
 using PInvoke;
 using StreamJsonRpc;
 using System;
@@ -13,16 +13,18 @@ namespace CefSharp.OutOfProcess.BrowserProcess
     public class BrowserProcessHandler : CefSharp.Handler.BrowserProcessHandler, IOutOfProcessClientRpc
     {
         private readonly int _parentProcessId;
-        private IList<OutOfProcessChromiumWebBrowser> _browsers = new List<OutOfProcessChromiumWebBrowser>();
+        private readonly bool _offscreenRendering;
+        private readonly IList<OutOfProcessChromiumWebBrowser> _browsers = new List<OutOfProcessChromiumWebBrowser>();
         /// <summary>
         /// JSON RPC used for IPC with host
         /// </summary>
         private JsonRpc _jsonRpc;
         private IOutOfProcessHostRpc _outOfProcessServer;
 
-        public BrowserProcessHandler(int parentProcessId)
+        public BrowserProcessHandler(int parentProcessId, bool offscreenRendering)
         {
             _parentProcessId = parentProcessId;
+            _offscreenRendering = offscreenRendering;
         }
 
         protected override void OnContextInitialized()
@@ -30,10 +32,9 @@ protected override void OnContextInitialized()
             base.OnContextInitialized();
 
             _jsonRpc = JsonRpc.Attach(Console.OpenStandardOutput(), Console.OpenStandardInput());
-            _outOfProcessServer = _jsonRpc.Attach<IOutOfProcessHostRpc>();
             _jsonRpc.AllowModificationWhileListening = true;
+            _outOfProcessServer = _jsonRpc.Attach<IOutOfProcessHostRpc>();
             _jsonRpc.AddLocalRpcTarget<IOutOfProcessClientRpc>(this, null);
-            _jsonRpc.AllowModificationWhileListening = false;
 
             var threadId = Kernel32.GetCurrentThreadId();
 
@@ -69,10 +70,25 @@ Task IOutOfProcessClientRpc.SendDevToolsMessage(int browserId, string message)
         {
             return CefThread.ExecuteOnUiThread(() =>
             {
-                var browser = _browsers.FirstOrDefault(x => x.Id == browserId);
+                GetBrowser(browserId)?.GetBrowserHost().SendDevToolsMessage(message);
+                return true;
+            });
+        }
 
-                browser?.GetBrowserHost().SendDevToolsMessage(message);
+        Task IOutOfProcessClientRpc.ShowDevTools(int browserId)
+        {
+            return CefThread.ExecuteOnUiThread(() =>
+            {
+                GetBrowser(browserId).ShowDevTools();
+                return true;
+            });
+        }
 
+        Task IOutOfProcessClientRpc.LoadUrl(int browserId, string url)
+        {
+            return CefThread.ExecuteOnUiThread(() =>
+            {
+                GetBrowser(browserId).LoadUrl(url);
                 return true;
             });
         }
@@ -93,15 +109,30 @@ Task IOutOfProcessClientRpc.CreateBrowser(IntPtr parentHwnd, string url, int id)
 
             return CefThread.ExecuteOnUiThread(() =>
             {
-                var browser = new OutOfProcessChromiumWebBrowser(_outOfProcessServer, id, url);
-
-                var windowInfo = new WindowInfo();
-                windowInfo.WindowName = "CefSharpBrowserProcess";
-                windowInfo.SetAsChild(parentHwnd);
-
-                //Disable Window activation by default
-                //https://bitbucket.org/chromiumembedded/cef/issues/1856/branch-2526-cef-activates-browser-window
-                windowInfo.ExStyle |= OutOfProcessChromiumWebBrowser.WS_EX_NOACTIVATE;
+                OutOfProcessChromiumWebBrowser browser;
+
+                IWindowInfo windowInfo;
+
+                if (_offscreenRendering)
+                {
+                    browser = new OffscreenOutOfProcessChromiumWebBrowser(_outOfProcessServer, id, url);
+                    windowInfo = Core.ObjectFactory.CreateWindowInfo();
+                    windowInfo.SetAsWindowless(parentHwnd);
+                    windowInfo.Width = 0;
+                    windowInfo.Height = 0;
+                }
+                else
+                {
+                    browser = new OutOfProcessChromiumWebBrowser(_outOfProcessServer, id, url);
+                    windowInfo = new WindowInfo();
+                    windowInfo.WindowName = "CefSharpBrowserProcess";
+                    windowInfo.SetAsChild(parentHwnd);
+
+                    //Disable Window activation by default
+                    //https://bitbucket.org/chromiumembedded/cef/issues/1856/branch-2526-cef-activates-browser-window
+                    windowInfo.ExStyle |= OutOfProcessChromiumWebBrowser.WS_EX_NOACTIVATE;
+
+                }
 
                 browser.CreateBrowser(windowInfo);
 
@@ -111,18 +142,39 @@ Task IOutOfProcessClientRpc.CreateBrowser(IntPtr parentHwnd, string url, int id)
             });
         }
 
-        void IOutOfProcessClientRpc.NotifyMoveOrResizeStarted(int browserId)
+        void IOutOfProcessClientRpc.NotifyMoveOrResizeStarted(int browserId, Rect rect)
         {
-            var browser = _browsers.FirstOrDefault(x => x.Id == browserId);
+            var browser = GetBrowser(browserId);
+            if(browser == null)
+            {
+                return;
+            }
 
-            browser?.GetBrowserHost().NotifyMoveOrResizeStarted();
+            var host = browser.GetBrowserHost();
+            host.NotifyMoveOrResizeStarted();
+
+            if (_offscreenRendering && browser is OffscreenOutOfProcessChromiumWebBrowser offscreenBrowser)
+            {
+                host.NotifyMoveOrResizeStarted();
+                offscreenBrowser.ViewRect = new Structs.Rect(rect.X, rect.Y, rect.Width, rect.Height);
+                host.WasResized();
+            }
         }
 
         void IOutOfProcessClientRpc.SetFocus(int browserId, bool focus)
         {
-            var browser = _browsers.FirstOrDefault(x => x.Id == browserId);
+            GetBrowser(browserId)?.GetBrowserHost().SetFocus(focus);
+        }
 
-            browser?.GetBrowserHost().SetFocus(focus);
+        void IOutOfProcessClientRpc.SendMouseClickEvent(int browserId, int x, int y, string mouseButtonType, bool mouseUp, int clickCount, uint eventFlags)
+        {
+            CefThread.ExecuteOnUiThread(() =>
+            {
+                GetBrowser(browserId)?.GetBrowserHost().SendMouseClickEvent(x, y, (MouseButtonType)Enum.Parse(typeof(MouseButtonType), mouseButtonType), mouseUp, clickCount, (CefEventFlags)eventFlags);
+                return true;
+            });
         }
+
+        private OutOfProcessChromiumWebBrowser GetBrowser(int id) => _browsers.FirstOrDefault(x => x.Id == id);
     }
-}
+}
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.BrowserProcess/CefSharp.WPF.Internals/RectStruct.cs b/CefSharp.OutOfProcess.BrowserProcess/CefSharp.WPF.Internals/RectStruct.cs
new file mode 100644
index 0000000..7999a6a
--- /dev/null
+++ b/CefSharp.OutOfProcess.BrowserProcess/CefSharp.WPF.Internals/RectStruct.cs
@@ -0,0 +1,48 @@
+// Copyright © 2018 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+using System.Runtime.InteropServices;
+using CefSharp.Structs;
+
+namespace CefSharp.Wpf.Internals
+{
+    /// <summary>
+    /// The RECT structure defines the coordinates of the upper-left and lower-right corners of a rectangle.
+    /// </summary>
+    /// <see cref="https://docs.microsoft.com/en-us/previous-versions/dd162897(v=vs.85)"/>
+    /// <remarks>
+    /// By convention, the right and bottom edges of the rectangle are normally considered exclusive. 
+    /// In other words, the pixel whose coordinates are ( right, bottom ) lies immediately outside of the the rectangle. 
+    /// For example, when RECT is passed to the FillRect function, the rectangle is filled up to, but not including, 
+    /// the right column and bottom row of pixels. This structure is identical to the RECTL structure.
+    /// </remarks>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct RectStruct
+    {
+        /// <summary>
+        /// The x-coordinate of the upper-left corner of the rectangle.
+        /// </summary>
+        public int Left;
+
+        /// <summary>
+        /// The y-coordinate of the upper-left corner of the rectangle.
+        /// </summary>
+        public int Top;
+
+        /// <summary>
+        /// The x-coordinate of the lower-right corner of the rectangle.
+        /// </summary>
+        public int Right;
+
+        /// <summary>
+        /// The y-coordinate of the lower-right corner of the rectangle.
+        /// </summary>
+        public int Bottom;
+
+        public static implicit operator Rect(RectStruct rect)
+        {
+            return new Rect(0, 0, rect.Right - rect.Left, rect.Bottom - rect.Top);
+        }
+    }
+}
diff --git a/CefSharp.OutOfProcess.BrowserProcess/OffscreenOutOfProcessChromiumWebBrowser.cs b/CefSharp.OutOfProcess.BrowserProcess/OffscreenOutOfProcessChromiumWebBrowser.cs
new file mode 100644
index 0000000..1b3274d
--- /dev/null
+++ b/CefSharp.OutOfProcess.BrowserProcess/OffscreenOutOfProcessChromiumWebBrowser.cs
@@ -0,0 +1,119 @@
+using CefSharp.Internals;
+using System;
+using CefSharp.OutOfProcess.Interface;
+using CefSharp.Structs;
+using CefSharp.Enums;
+
+namespace CefSharp.OutOfProcess.BrowserProcess
+{
+    /// <summary>
+    /// An ChromiumWebBrowser instance specifically for hosting CEF out of process
+    /// </summary>
+    public class OffscreenOutOfProcessChromiumWebBrowser : OutOfProcessChromiumWebBrowser, IRenderWebBrowser
+    {
+        private readonly RenderHandler renderHandler;
+        private readonly RenderHandler popupRenderHandler;
+
+        public OffscreenOutOfProcessChromiumWebBrowser(IOutOfProcessHostRpc outOfProcessServer, int id, string address = "", IRequestContext requestContext = null)
+          : base(outOfProcessServer, id, address, requestContext, true)
+        {
+            renderHandler = new RenderHandler($"0render_{Id}_");
+            popupRenderHandler = new RenderHandler($"0render_{Id}_popup_");
+        }
+
+        /// <summary>
+        /// The dpi scale factor, if the browser has already been initialized
+        /// you must manually call IBrowserHost.NotifyScreenInfoChanged for the
+        /// browser to be notified of the change.
+        /// </summary>
+        public float DpiScaleFactor { get; set; } = 1;
+
+        internal CefSharp.Structs.Rect ViewRect { get; set; }
+
+        /// <summary>
+        /// Gets the ScreenInfo - currently used to get the DPI scale factor.
+        /// </summary>
+        /// <returns>ScreenInfo containing the current DPI scale factor</returns>
+        ScreenInfo? IRenderWebBrowser.GetScreenInfo() => GetScreenInfo();
+
+        /// <summary>
+        /// Gets the ScreenInfo - currently used to get the DPI scale factor.
+        /// </summary>
+        /// <returns>ScreenInfo containing the current DPI scale factor</returns>
+        protected virtual ScreenInfo? GetScreenInfo()
+        {
+            CefSharp.Structs.Rect rect = new CefSharp.Structs.Rect();
+            CefSharp.Structs.Rect availableRect = new CefSharp.Structs.Rect();
+
+            if (DpiScaleFactor > 1.0)
+            {
+                rect = rect.ScaleByDpi(DpiScaleFactor);
+                availableRect = availableRect.ScaleByDpi(DpiScaleFactor);
+            }
+
+            var screenInfo = new ScreenInfo
+            {
+                DeviceScaleFactor = DpiScaleFactor,
+                Rect = rect,
+                AvailableRect = availableRect,
+            };
+
+            return screenInfo;
+        }
+
+        Structs.Rect IRenderWebBrowser.GetViewRect() => ViewRect;
+
+        bool IRenderWebBrowser.GetScreenPoint(int viewX, int viewY, out int screenX, out int screenY)
+        {
+            screenX = ViewRect.X + viewX;
+            screenY = ViewRect.Y + viewY;
+
+            return true;
+        }
+
+        void IRenderWebBrowser.OnAcceleratedPaint(PaintElementType type, Structs.Rect dirtyRect, IntPtr sharedHandle)
+        {
+            throw new NotImplementedException();
+        }
+
+        void IRenderWebBrowser.OnPaint(PaintElementType type, Structs.Rect dirtyRect, IntPtr buffer, int width, int height)
+        {
+            var dirtyRectCopy = new Interface.Rect(dirtyRect.X, dirtyRect.Y, dirtyRect.Width, dirtyRect.Height);
+            string file = type == PaintElementType.Popup
+                ? popupRenderHandler.OnPaint(buffer, width, height)
+                : renderHandler.OnPaint(buffer, width, height);
+
+            OutofProcessHostRpc.NotifyPaint(Id, type == PaintElementType.Popup, dirtyRectCopy, width, height, file);
+        }
+
+        void IRenderWebBrowser.OnCursorChange(IntPtr cursor, CursorType type, CursorInfo customCursorInfo)
+        {
+            // not implemented
+        }
+
+        bool IRenderWebBrowser.StartDragging(IDragData dragData, DragOperationsMask mask, int x, int y)
+        {
+            // not implemented
+            return false;
+        }
+
+        void IRenderWebBrowser.UpdateDragCursor(DragOperationsMask operation)
+        {
+            // not implemented
+        }
+
+        void IRenderWebBrowser.OnPopupShow(bool show) => OutofProcessHostRpc.NotifyPopupShow(Id, show);
+
+        void IRenderWebBrowser.OnPopupSize(CefSharp.Structs.Rect rect) => OutofProcessHostRpc.NotifyPopupSize(Id, new Interface.Rect(rect.X, rect.Y, rect.Width, rect.Height));
+
+        void IRenderWebBrowser.OnImeCompositionRangeChanged(Structs.Range selectedRange, CefSharp.Structs.Rect[] characterBounds)
+        {
+            throw new NotImplementedException();
+        }
+
+        void IRenderWebBrowser.OnVirtualKeyboardRequested(IBrowser browser, TextInputMode inputMode)
+        {
+            // not implemented
+        }
+    }
+}
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.BrowserProcess/OutOfProcessChromiumWebBrowser.cs b/CefSharp.OutOfProcess.BrowserProcess/OutOfProcessChromiumWebBrowser.cs
index 63966f8..49181b2 100644
--- a/CefSharp.OutOfProcess.BrowserProcess/OutOfProcessChromiumWebBrowser.cs
+++ b/CefSharp.OutOfProcess.BrowserProcess/OutOfProcessChromiumWebBrowser.cs
@@ -1,4 +1,4 @@
-using CefSharp.Internals;
+using CefSharp.Internals;
 using System;
 using System.Threading.Tasks;
 using System.Threading;
@@ -7,15 +7,13 @@
 using System.IO;
 using CefSharp.OutOfProcess.Interface;
 using System.Runtime.InteropServices;
-using PInvoke;
-using System.Diagnostics;
 
 namespace CefSharp.OutOfProcess.BrowserProcess
 {
     /// <summary>
     /// An ChromiumWebBrowser instance specifically for hosting CEF out of process
     /// </summary>
-    public partial class OutOfProcessChromiumWebBrowser : IWebBrowserInternal
+    public class OutOfProcessChromiumWebBrowser : IWebBrowserInternal
     {
         public const string BrowserNotInitializedExceptionErrorMessage =
             "The ChromiumWebBrowser instance creates the underlying Chromium Embedded Framework (CEF) browser instance in an async fashion. " +
@@ -36,7 +34,7 @@ public partial class OutOfProcessChromiumWebBrowser : IWebBrowserInternal
         /// <summary>
         /// Internal ID used for tracking browsers between Processes;
         /// </summary>
-        private int _id;
+        private readonly int _id;
 
         /// <summary>
         /// The managed cef browser adapter
@@ -46,7 +44,7 @@ public partial class OutOfProcessChromiumWebBrowser : IWebBrowserInternal
         /// <summary>
         /// JSON RPC used for IPC with host
         /// </summary>
-        private IOutOfProcessHostRpc _outofProcessHostRpc;
+        private readonly IOutOfProcessHostRpc _outofProcessHostRpc;
 
         /// <summary>
         /// Flag to guard the creation of the underlying browser - only one instance can be created
@@ -178,6 +176,11 @@ public partial class OutOfProcessChromiumWebBrowser : IWebBrowserInternal
         /// <value>The resource handler factory.</value>
         public IResourceRequestHandlerFactory ResourceRequestHandlerFactory { get; set; }
 
+        /// <summary>
+        /// Gets the out of process host.
+        /// </summary>
+        private protected IOutOfProcessHostRpc OutofProcessHostRpc => _outofProcessHostRpc;
+
         /// <summary>
         /// Event handler that will get called when the resource load for a navigation fails or is canceled.
         /// It's important to note this event is fired on a CEF UI thread, which by default is not the same as your application UI
@@ -453,7 +456,10 @@ private void RemoveExNoActivateStyle(IntPtr hwnd)
         /// <inheritdoc/>
         public void LoadUrl(string url)
         {
-            throw new NotImplementedException();
+            using (var frame = _browser.MainFrame)
+            {
+                frame.LoadUrl(url);
+            }
         }
 
         /// <inheritdoc/>
@@ -665,7 +671,7 @@ public bool IsBrowserInitialized
         /// </param>
         /// <exception cref="System.InvalidOperationException">Cef::Initialize() failed</exception>
         public OutOfProcessChromiumWebBrowser(IOutOfProcessHostRpc outOfProcessServer, int id, string address = "",
-            IRequestContext requestContext = null)
+            IRequestContext requestContext = null, bool offscreenRendering = false)
         {
             _id = id;
             RequestContext = requestContext;
@@ -674,7 +680,7 @@ public OutOfProcessChromiumWebBrowser(IOutOfProcessHostRpc outOfProcessServer, i
             Cef.AddDisposable(this);
             Address = address;
 
-            _managedCefBrowserAdapter = ManagedCefBrowserAdapter.Create(this, false);
+            _managedCefBrowserAdapter = ManagedCefBrowserAdapter.Create(this, offscreenRendering);
         }
 
         /// <summary>
@@ -774,7 +780,7 @@ public void CreateBrowser(IWindowInfo windowInfo = null, IBrowserSettings browse
 
             //We actually check if WS_EX_NOACTIVATE was set for instances
             //the user has override CreateBrowserWindowInfo and not called base.CreateBrowserWindowInfo
-            _removeExNoActivateStyle = (windowInfo.ExStyle & WS_EX_NOACTIVATE) == WS_EX_NOACTIVATE;
+            _removeExNoActivateStyle = !windowInfo.WindowlessRenderingEnabled && (windowInfo.ExStyle & WS_EX_NOACTIVATE) == WS_EX_NOACTIVATE;
 
             //TODO: We need some sort of timeout and
             //if we use the same approach for WPF/WinForms then
diff --git a/CefSharp.OutOfProcess.BrowserProcess/Program.cs b/CefSharp.OutOfProcess.BrowserProcess/Program.cs
index 39f6b0b..c585f18 100644
--- a/CefSharp.OutOfProcess.BrowserProcess/Program.cs
+++ b/CefSharp.OutOfProcess.BrowserProcess/Program.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Diagnostics;
 using System.Threading.Tasks;
 using CefSharp.Internals;
@@ -18,6 +18,7 @@ public static int Main(string[] args)
 
             var parentProcessId = int.Parse(CommandLineArgsParser.GetArgumentValue(args, "--parentProcessId"));
             var cachePath = CommandLineArgsParser.GetArgumentValue(args, "--cachePath");
+            var offscreenRendering = bool.Parse(CommandLineArgsParser.GetArgumentValue(args, "--offscreenRendering"));
 
             var parentProcess = Process.GetProcessById(parentProcessId);
 
@@ -25,10 +26,11 @@ public static int Main(string[] args)
             {
                 //By default CefSharp will use an in-memory cache, you need to specify a Cache Folder to persist data
                 CachePath = cachePath,
+                WindowlessRenderingEnabled = offscreenRendering,
                 MultiThreadedMessageLoop = false
             };
 
-            var browserProcessHandler = new BrowserProcessHandler(parentProcessId);
+            var browserProcessHandler = new BrowserProcessHandler(parentProcessId, offscreenRendering);
 
             Cef.EnableWaitForBrowsersToClose();
 
diff --git a/CefSharp.OutOfProcess.BrowserProcess/RenderHandler.cs b/CefSharp.OutOfProcess.BrowserProcess/RenderHandler.cs
new file mode 100644
index 0000000..036bb84
--- /dev/null
+++ b/CefSharp.OutOfProcess.BrowserProcess/RenderHandler.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Runtime.InteropServices;
+using System.IO.MemoryMappedFiles;
+
+namespace CefSharp.OutOfProcess.BrowserProcess
+{
+    internal sealed class RenderHandler : IDisposable
+    {
+        private readonly string renderFileNameTemplate;
+        private string renderFileName;
+        private MemoryMappedViewAccessor viewAccessor;
+        private MemoryMappedFile mappedFile;
+        private int currentAvailableBytes = 0;
+
+        public RenderHandler(string fileName)
+        {
+            renderFileNameTemplate = fileName;
+        }
+
+        public string OnPaint(IntPtr buffer, int width, int height)
+        {
+            const int bytesPerPixel = 32 / 8;
+            const int reserverdSizeBits = 2 * sizeof(int);
+            int maximumPixels = width * height;
+            int requiredfBytes = (maximumPixels * bytesPerPixel) + reserverdSizeBits;
+
+            bool createNewBitmap = mappedFile == null || currentAvailableBytes < requiredfBytes;
+
+            if (createNewBitmap)
+            {
+                currentAvailableBytes = requiredfBytes;
+
+                if (mappedFile != null)
+                {
+                    mappedFile.SafeMemoryMappedFileHandle.Close();
+                    mappedFile.Dispose();
+
+                    viewAccessor.SafeMemoryMappedViewHandle.Close();
+                    viewAccessor.Dispose();
+                }
+
+                renderFileName = renderFileNameTemplate + Guid.NewGuid();
+
+                mappedFile = MemoryMappedFile.CreateNew(renderFileName, requiredfBytes, MemoryMappedFileAccess.ReadWrite);
+                viewAccessor = mappedFile.CreateViewAccessor(0, requiredfBytes, MemoryMappedFileAccess.Write);
+            }
+
+            var ptr = viewAccessor.SafeMemoryMappedViewHandle.DangerousGetHandle();
+
+            Marshal.WriteInt32(ptr, width);
+            Marshal.WriteInt32(ptr + sizeof(int), height);
+            CopyMemory(ptr + reserverdSizeBits, buffer, (uint)requiredfBytes - reserverdSizeBits);
+
+            viewAccessor.Flush();
+
+            return renderFileName;
+        }
+
+        [DllImport("kernel32.dll", EntryPoint = "RtlMoveMemory", ExactSpelling = true)]
+        public static extern void CopyMemory(IntPtr dest, IntPtr src, uint count);
+
+        public void Dispose()
+        {
+            viewAccessor?.Dispose();
+            mappedFile?.Dispose();
+        }
+    }
+}
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.Core/CefEventFlags.cs b/CefSharp.OutOfProcess.Core/CefEventFlags.cs
new file mode 100644
index 0000000..ef118a5
--- /dev/null
+++ b/CefSharp.OutOfProcess.Core/CefEventFlags.cs
@@ -0,0 +1,40 @@
+// Copyright © 2015 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+using System;
+
+
+namespace CefSharp.OutOfProcess
+{
+    /// <summary>
+    /// Supported event bit flags.
+    /// </summary>
+    [Flags]
+    public enum CefEventFlags : uint
+    {
+        None = 0,
+
+        CapsLockOn = 1 << 0,
+
+        ShiftDown = 1 << 1,
+        ControlDown = 1 << 2,
+        AltDown = 1 << 3,
+
+        LeftMouseButton = 1 << 4,
+        MiddleMouseButton = 1 << 5,
+        RightMouseButton = 1 << 6,
+
+        /// <summary>
+        /// Mac OS-X command key.
+        /// </summary>
+        CommandDown = 1 << 7,
+
+        NumLockOn = 1 << 8,
+        IsKeyPad = 1 << 9,
+        IsLeft = 1 << 10,
+        IsRight = 1 << 11,
+        AltGrDown = 1 << 12,
+        IsRepeat = 1 << 13,
+    }
+}
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.Core/IChromiumWebBrowser.cs b/CefSharp.OutOfProcess.Core/IChromiumWebBrowser.cs
index 9704d7b..1b8cfc7 100644
--- a/CefSharp.OutOfProcess.Core/IChromiumWebBrowser.cs
+++ b/CefSharp.OutOfProcess.Core/IChromiumWebBrowser.cs
@@ -1,4 +1,4 @@
-using CefSharp.Dom;
+using CefSharp.Dom;
 using System;
 using System.Threading.Tasks;
 
diff --git a/CefSharp.OutOfProcess.Core/Internal/IRenderHandlerInternal.cs b/CefSharp.OutOfProcess.Core/Internal/IRenderHandlerInternal.cs
new file mode 100644
index 0000000..c55234f
--- /dev/null
+++ b/CefSharp.OutOfProcess.Core/Internal/IRenderHandlerInternal.cs
@@ -0,0 +1,13 @@
+using CefSharp.OutOfProcess.Interface;
+
+namespace CefSharp.OutOfProcess.Internal
+{
+    public interface IRenderHandlerInternal
+    {
+        void OnPaint(bool isPopup, Rect dirtyRect, int width, int height, string file);
+
+        void OnPopupShow(bool show);
+
+        void OnPopupSize(Rect rect);
+    }
+}
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.Core/MouseButtonType.cs b/CefSharp.OutOfProcess.Core/MouseButtonType.cs
new file mode 100644
index 0000000..ec921bc
--- /dev/null
+++ b/CefSharp.OutOfProcess.Core/MouseButtonType.cs
@@ -0,0 +1,25 @@
+// Copyright © 2015 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+namespace CefSharp.OutOfProcess
+{
+    /// <summary>
+    /// Values that represent mouse button types.
+    /// </summary>
+    public enum MouseButtonType
+    {
+        /// <summary>
+        /// Left Mouse Button
+        /// </summary>
+        Left = 0,
+        /// <summary>
+        /// Middle Mouse Button
+        /// </summary>
+        Middle,
+        /// <summary>
+        /// Right Mouse Button
+        /// </summary>
+        Right
+    }
+}
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.Core/OutOfProcessConnectionTransport.cs b/CefSharp.OutOfProcess.Core/OutOfProcessConnectionTransport.cs
index a08309f..43d6b82 100644
--- a/CefSharp.OutOfProcess.Core/OutOfProcessConnectionTransport.cs
+++ b/CefSharp.OutOfProcess.Core/OutOfProcessConnectionTransport.cs
@@ -1,4 +1,4 @@
-using CefSharp.Dom.Transport;
+using CefSharp.Dom.Transport;
 using System;
 using System.Threading.Tasks;
 
@@ -12,6 +12,7 @@ public class OutOfProcessConnectionTransport : IConnectionTransport
 
         public event EventHandler<MessageReceivedEventArgs> MessageReceived;
         public event EventHandler<MessageErrorEventArgs> MessageError;
+        public event EventHandler Disconnected;
 
         public OutOfProcessConnectionTransport(int browserId, OutOfProcessHost outOfProcessHost)
         {
diff --git a/CefSharp.OutOfProcess.Core/OutOfProcessHost.cs b/CefSharp.OutOfProcess.Core/OutOfProcessHost.cs
index 1fec5c4..69899d5 100644
--- a/CefSharp.OutOfProcess.Core/OutOfProcessHost.cs
+++ b/CefSharp.OutOfProcess.Core/OutOfProcessHost.cs
@@ -1,4 +1,4 @@
-using CefSharp.OutOfProcess.Interface;
+using CefSharp.OutOfProcess.Interface;
 using CefSharp.OutOfProcess.Internal;
 using PInvoke;
 using StreamJsonRpc;
@@ -17,6 +17,7 @@ public class OutOfProcessHost : IOutOfProcessHostRpc, IDisposable
         /// </summary>
         public const string HostExeName = "CefSharp.OutOfProcess.BrowserProcess.exe";
 
+        private readonly bool _offscreenRendering;
         private Process _browserProcess;
         private JsonRpc _jsonRpc;
         private IOutOfProcessClientRpc _outOfProcessClient;
@@ -31,10 +32,11 @@ public class OutOfProcessHost : IOutOfProcessHostRpc, IDisposable
         private ConcurrentDictionary<int, IChromiumWebBrowserInternal> _browsers = new ConcurrentDictionary<int, IChromiumWebBrowserInternal>();
         private TaskCompletionSource<OutOfProcessHost> _processInitialized = new TaskCompletionSource<OutOfProcessHost>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        private OutOfProcessHost(string outOfProcessHostExePath, string cachePath = null)
+        private OutOfProcessHost(string outOfProcessHostExePath, string cachePath = null, bool offscreenRendering = false)
         {
             _outofProcessHostExePath = outOfProcessHostExePath;
             _cachePath = cachePath;
+            _offscreenRendering = offscreenRendering;
         }
 
         /// <summary>
@@ -94,6 +96,21 @@ public bool CreateBrowser(IChromiumWebBrowserInternal browser, IntPtr handle, st
             return _browsers.TryAdd(id, browser);
         }
 
+        public Task ShowDevTools(int browserId)
+        {
+            return _outOfProcessClient.ShowDevTools(browserId);
+        }
+
+        public void SendMouseClickEvent(int browserId, int x, int y, MouseButtonType mouseButtonType, bool mouseUp, int clickCount, CefEventFlags eventFlags)
+        {
+            _outOfProcessClient.SendMouseClickEvent(browserId, x, y, mouseButtonType.ToString(), mouseUp, clickCount, (uint)eventFlags);
+        }
+
+        public Task LoadUrl(int browserId, string url)
+        {
+            return _outOfProcessClient.LoadUrl(browserId, url);
+        }
+
         internal Task SendDevToolsMessageAsync(int browserId, string message)
         {
             return _outOfProcessClient.SendDevToolsMessage(browserId, message);
@@ -108,12 +125,13 @@ private void Init()
         {
             var currentProcess = Process.GetCurrentProcess();
 
-            var args = $"--parentProcessId={currentProcess.Id} --cachePath={_cachePath}";
+            var args = $"--parentProcessId={currentProcess.Id} --cachePath={_cachePath} --offscreenRendering={_offscreenRendering}";
 
             _browserProcess = Process.Start(new ProcessStartInfo(_outofProcessHostExePath, args)
             {
                 RedirectStandardInput = true,
                 RedirectStandardOutput = true,
+                UseShellExecute = false,
             });
 
             _browserProcess.Exited += OnBrowserProcessExited;
@@ -135,18 +153,12 @@ private void OnBrowserProcessExited(object sender, EventArgs e)
 
         void IOutOfProcessHostRpc.NotifyAddressChanged(int browserId, string address)
         {
-            if (_browsers.TryGetValue(browserId, out var chromiumWebBrowser))
-            {
-                chromiumWebBrowser.SetAddress(address);
-            }
+            GetBrowser(browserId)?.SetAddress(address);
         }
 
         void IOutOfProcessHostRpc.NotifyBrowserCreated(int browserId, IntPtr browserHwnd)
         {
-            if (_browsers.TryGetValue(browserId, out var chromiumWebBrowser))
-            {
-                chromiumWebBrowser.OnAfterBrowserCreated(browserHwnd);
-            }
+            GetBrowser(browserId)?.OnAfterBrowserCreated(browserHwnd);
         }
 
         void IOutOfProcessHostRpc.NotifyContextInitialized(int threadId, string cefSharpVersion, string cefVersion, string chromiumVersion)
@@ -169,47 +181,47 @@ void IOutOfProcessHostRpc.NotifyDevToolsAgentDetached(int browserId)
 
         void IOutOfProcessHostRpc.NotifyDevToolsMessage(int browserId, string devToolsMessage)
         {
-            if (_browsers.TryGetValue(browserId, out var chromiumWebBrowser))
-            {
-                chromiumWebBrowser.OnDevToolsMessage(devToolsMessage);
-            }
+            GetBrowser(browserId)?.OnDevToolsMessage(devToolsMessage);
         }
 
         void IOutOfProcessHostRpc.NotifyDevToolsReady(int browserId)
         {
-            if (_browsers.TryGetValue(browserId, out var chromiumWebBrowser))
-            {
-                chromiumWebBrowser.OnDevToolsReady();
-            }
+            GetBrowser(browserId)?.OnDevToolsReady();
         }
 
         void IOutOfProcessHostRpc.NotifyLoadingStateChange(int browserId, bool canGoBack, bool canGoForward, bool isLoading)
         {
-            if (_browsers.TryGetValue(browserId, out var chromiumWebBrowser))
-            {
-                chromiumWebBrowser.SetLoadingStateChange(canGoBack, canGoForward, isLoading);
-            }
+            GetBrowser(browserId)?.SetLoadingStateChange(canGoBack, canGoForward, isLoading);
         }
 
         void IOutOfProcessHostRpc.NotifyStatusMessage(int browserId, string statusMessage)
         {
-            if (_browsers.TryGetValue(browserId, out var chromiumWebBrowser))
-            {
-                chromiumWebBrowser.SetStatusMessage(statusMessage);
-            }
+            GetBrowser(browserId)?.SetStatusMessage(statusMessage);
         }
 
         void IOutOfProcessHostRpc.NotifyTitleChanged(int browserId, string title)
         {
-            if (_browsers.TryGetValue(browserId, out var chromiumWebBrowser))
-            {
-                chromiumWebBrowser.SetTitle(title);
-            }
+            GetBrowser(browserId)?.SetTitle(title);
+        }
+
+        void IOutOfProcessHostRpc.NotifyPaint(int browserId, bool isPopup, Rect dirtyRect, int width, int height, string file)
+        {
+            ((IRenderHandlerInternal)GetBrowser(browserId))?.OnPaint(isPopup, dirtyRect, width, height, file);
+        }
+
+        void IOutOfProcessHostRpc.NotifyPopupShow(int browserId, bool show)
+        {
+            ((IRenderHandlerInternal)GetBrowser(browserId))?.OnPopupShow(show);
         }
 
-        public void NotifyMoveOrResizeStarted(int id)
+        void IOutOfProcessHostRpc.NotifyPopupSize(int browserId, Rect rect)
         {
-            _outOfProcessClient.NotifyMoveOrResizeStarted(id);
+            ((IRenderHandlerInternal)GetBrowser(browserId))?.OnPopupSize(rect);
+        }
+
+        public void NotifyMoveOrResizeStarted(int id, Rect rect = default)
+        {
+            _outOfProcessClient.NotifyMoveOrResizeStarted(id, rect);
         }
 
         /// <summary>
@@ -225,6 +237,7 @@ public void SetFocus(int id, bool focus)
         public void CloseBrowser(int id)
         {
             _ = _outOfProcessClient.CloseBrowser(id);
+            _browsers.TryRemove(id, out _);
         }
 
         public void Dispose()
@@ -234,7 +247,7 @@ public void Dispose()
             _jsonRpc = null;
         }
 
-        public static Task<OutOfProcessHost> CreateAsync(string path = HostExeName, string cachePath = null)
+        public static Task<OutOfProcessHost> CreateAsync(string path = HostExeName, string cachePath = null, bool offScreenRendering = false)
         {
             if(string.IsNullOrEmpty(path))
             {
@@ -248,11 +261,21 @@ public static Task<OutOfProcessHost> CreateAsync(string path = HostExeName, stri
                 throw new FileNotFoundException("Unable to find Host executable.", path);
             }
 
-            var host = new OutOfProcessHost(fullPath, cachePath);
+            var host = new OutOfProcessHost(fullPath, cachePath, offScreenRendering);
 
             host.Init();            
 
             return host.InitializedTask;
-        }        
+        }
+
+        private IChromiumWebBrowserInternal GetBrowser(int browserId)
+        {
+            if (_browsers.TryGetValue(browserId, out var chromiumWebBrowser))
+            {
+                return chromiumWebBrowser;
+            }
+
+            return null;
+        }
     }
 }
diff --git a/CefSharp.OutOfProcess.Interface/IOutOfProcessClientRpc.cs b/CefSharp.OutOfProcess.Interface/IOutOfProcessClientRpc.cs
index ffa40e8..35b007f 100644
--- a/CefSharp.OutOfProcess.Interface/IOutOfProcessClientRpc.cs
+++ b/CefSharp.OutOfProcess.Interface/IOutOfProcessClientRpc.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Threading.Tasks;
 
 namespace CefSharp.OutOfProcess.Interface
@@ -19,10 +19,14 @@ public interface IOutOfProcessClientRpc
         /// Send DevTools message
         /// </summary>
         /// <param name="browserId">browser Id</param>
-        /// <param name="message"devtools message (json)></param>
+        /// <param name="message">devtools message (json)</param>
         /// <returns>Task</returns>
         Task SendDevToolsMessage(int browserId, string message);
 
+        Task ShowDevTools(int browserId);
+
+        Task LoadUrl(int browserId, string url);
+
         /// <summary>
         /// Close the Browser Process (host)
         /// </summary>
@@ -43,7 +47,8 @@ public interface IOutOfProcessClientRpc
         /// This will dismiss any existing popups (dropdowns).
         /// </summary>
         /// <param name="browserId">browser Id</param>
-        void NotifyMoveOrResizeStarted(int browserId);
+        /// <param name="browserId">Position and size of the window. Only required in offscreen mode.</param>
+        void NotifyMoveOrResizeStarted(int browserId, Rect rect = default);
 
         /// <summary>
         /// Set whether the browser is focused.
@@ -51,5 +56,18 @@ public interface IOutOfProcessClientRpc
         /// <param name="id">browser id</param>
         /// <param name="focus">set focus</param>
         void SetFocus(int browserId, bool focus);
+
+        /// <summary>
+        /// Sends a mouse click to the client.
+        /// Custom implementation necessary because IDevToolsContext can't handle clicks on popups
+        /// </summary>
+        /// <param name="browserId"></param>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <param name="mouseButtonType"></param>
+        /// <param name="mouseUp"></param>
+        /// <param name="clickCount"></param>
+        /// <param name="eventFlags"></param>
+        void SendMouseClickEvent(int browserId, int x, int y, string mouseButtonType, bool mouseUp, int clickCount, uint eventFlags);
     }
 }
diff --git a/CefSharp.OutOfProcess.Interface/IOutOfProcessHostRpc.cs b/CefSharp.OutOfProcess.Interface/IOutOfProcessHostRpc.cs
index 2ff909e..f6f521c 100644
--- a/CefSharp.OutOfProcess.Interface/IOutOfProcessHostRpc.cs
+++ b/CefSharp.OutOfProcess.Interface/IOutOfProcessHostRpc.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace CefSharp.OutOfProcess.Interface
 {
@@ -78,5 +78,11 @@ public interface IOutOfProcessHostRpc
         /// <param name="cefVersion">Cef Version</param>
         /// <param name="chromiumVersion">Chromium Version</param>
         void NotifyContextInitialized(int threadId, string cefSharpVersion, string cefVersion, string chromiumVersion);
+
+        void NotifyPaint(int browserId, bool isPopup, Rect dirtyRect, int width, int height, string file);
+
+        void NotifyPopupShow(int browserId, bool show);
+
+        void NotifyPopupSize(int browserId, Rect rect);
     }
-}
+}
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.Interface/Rect.cs b/CefSharp.OutOfProcess.Interface/Rect.cs
new file mode 100644
index 0000000..cd48c0a
--- /dev/null
+++ b/CefSharp.OutOfProcess.Interface/Rect.cs
@@ -0,0 +1,51 @@
+// Copyright © 2015 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+using System.Diagnostics;
+
+namespace CefSharp.OutOfProcess.Interface
+{
+    /// <summary>
+    /// Represents a rectangle
+    /// </summary>
+    [DebuggerDisplay("X = {X}, Y = {Y}, Width = {Width}, Height = {Height}")]
+    public struct Rect
+    {
+        /// <summary>
+        /// X coordinate
+        /// </summary>
+        public int X { get; private set; }
+
+        /// <summary>
+        /// Y coordinate
+        /// </summary>
+        public int Y { get; private set; }
+
+        /// <summary>
+        /// Width
+        /// </summary>
+        public int Width { get; private set; }
+
+        /// <summary>
+        /// Height
+        /// </summary>
+        public int Height { get; private set; }
+
+        /// <summary>
+        /// Rect
+        /// </summary>
+        /// <param name="x">x coordinate</param>
+        /// <param name="y">y coordinate</param>
+        /// <param name="width">width</param>
+        /// <param name="height">height</param>
+        public Rect(int x, int y, int width, int height)
+            : this()
+        {
+            X = x;
+            Y = y;
+            Width = width;
+            Height = height;
+        }
+    }
+}
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/App.config b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/App.config
new file mode 100644
index 0000000..81ca9c6
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/App.config
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+  <startup>
+    <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
+  </startup>
+</configuration>
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/App.xaml b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/App.xaml
new file mode 100644
index 0000000..cd28f96
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/App.xaml
@@ -0,0 +1,11 @@
+<Application x:Class="CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:converter="clr-namespace:CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.Converter"
+             StartupUri="MainWindow.xaml">
+    <Application.Resources>
+        <converter:TitleConverter x:Key="TitleConverter"/>
+        <converter:EnvironmentConverter x:Key="EnvironmentConverter" />
+        <BooleanToVisibilityConverter x:Key="BooleanToVisibilityConverter" />
+    </Application.Resources>
+</Application>
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/App.xaml.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/App.xaml.cs
new file mode 100644
index 0000000..589e16d
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/App.xaml.cs
@@ -0,0 +1,16 @@
+// Copyright © 2022 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+using System.Windows;
+
+namespace CefSharp.OutOfProcess.Wpf.OffscreenHost.Example
+{
+    /// <summary>
+    /// Interaction logic for App.xaml
+    /// </summary>
+    public partial class App : Application
+    {
+
+    }
+}
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/AssemblyInfo.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/AssemblyInfo.cs
new file mode 100644
index 0000000..ed33db9
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/AssemblyInfo.cs
@@ -0,0 +1,14 @@
+// Copyright © 2019 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+using System.Windows;
+
+[assembly: ThemeInfo(
+    ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
+                                     //(used if a resource is not found in the page,
+                                     // or application resource dictionaries)
+    ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
+                                              //(used if a resource is not found in the page,
+                                              // app, or any theme specific resource dictionaries)
+)]
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Behaviours/HoverLinkBehaviour.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Behaviours/HoverLinkBehaviour.cs
new file mode 100644
index 0000000..b67fdd2
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Behaviours/HoverLinkBehaviour.cs
@@ -0,0 +1,34 @@
+using System.Windows;
+using System;
+using Microsoft.Xaml.Behaviors;
+
+namespace CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.Behaviours
+{
+    public class HoverLinkBehaviour : Behavior<OffscreenChromiumWebBrowser>
+    {
+        // Using a DependencyProperty as the backing store for HoverLink. This enables animation, styling, binding, etc...
+        public static readonly DependencyProperty HoverLinkProperty = DependencyProperty.Register("HoverLink", typeof(string), typeof(HoverLinkBehaviour), new PropertyMetadata(string.Empty));
+
+        public string HoverLink
+        {
+            get { return (string)GetValue(HoverLinkProperty); }
+            set { SetValue(HoverLinkProperty, value); }
+        }
+
+        protected override void OnAttached()
+        {
+            AssociatedObject.StatusMessage += OnStatusMessageChanged;
+        }
+
+        protected override void OnDetaching()
+        {
+            AssociatedObject.StatusMessage -= OnStatusMessageChanged;
+        }
+
+        private void OnStatusMessageChanged(object sender, StatusMessageEventArgs e)
+        {
+            var chromiumWebBrowser = sender as OffscreenChromiumWebBrowser;
+            chromiumWebBrowser.Dispatcher.BeginInvoke((Action)(() => HoverLink = e.Value));
+        }
+    }
+}
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Behaviours/TextBoxBindingUpdateOnEnterBehaviour.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Behaviours/TextBoxBindingUpdateOnEnterBehaviour.cs
new file mode 100644
index 0000000..0d9b1f8
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Behaviours/TextBoxBindingUpdateOnEnterBehaviour.cs
@@ -0,0 +1,28 @@
+namespace CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.Behaviours
+{
+    using System.Windows.Controls;
+    using System.Windows.Input;
+    using Microsoft.Xaml.Behaviors;
+
+    public class TextBoxBindingUpdateOnEnterBehaviour : Behavior<TextBox>
+    {
+        protected override void OnAttached()
+        {
+            AssociatedObject.KeyDown += OnTextBoxKeyDown;
+        }
+
+        protected override void OnDetaching()
+        {
+            AssociatedObject.KeyDown -= OnTextBoxKeyDown;
+        }
+
+        private void OnTextBoxKeyDown(object sender, KeyEventArgs e)
+        {
+            if (e.Key == Key.Enter)
+            {
+                var txtBox = sender as TextBox;
+                txtBox.GetBindingExpression(TextBox.TextProperty).UpdateSource();
+            }
+        }
+    }
+}
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.csproj b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.csproj
new file mode 100644
index 0000000..10c912a
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.csproj
@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <UseWPF>true</UseWPF>
+	<TargetFrameworks>netcoreapp3.1;net462</TargetFrameworks>
+    <RootNamespace>CefSharp.OutOfProcess.Wpf.OffscreenHost.Example</RootNamespace>
+    <StartupObject>CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.App</StartupObject>
+	  <PlatformTarget>AnyCPU</PlatformTarget>
+    <ApplicationManifest>app.manifest</ApplicationManifest>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Xaml.Behaviors.Wpf" Version="1.1.19" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\CefSharp.OutOfProcess.Core\CefSharp.OutOfProcess.Core.csproj" />
+    <ProjectReference Include="..\CefSharp.OutOfProcess.Wpf.OffscreenHost\CefSharp.OutOfProcess.Wpf.OffscreenHost.csproj" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Converter/EnvironmentConverter.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Converter/EnvironmentConverter.cs
new file mode 100644
index 0000000..0c18b5e
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Converter/EnvironmentConverter.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Globalization;
+using System.Windows.Data;
+
+namespace CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.Converter
+{
+    public class EnvironmentConverter : IValueConverter
+    {
+        object IValueConverter.Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            return Environment.Is64BitProcess ? "x64" : "x86";
+        }
+
+        object IValueConverter.ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            return Binding.DoNothing;
+        }
+    }
+}
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Converter/TitleConverter.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Converter/TitleConverter.cs
new file mode 100644
index 0000000..dfa888c
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Converter/TitleConverter.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Globalization;
+using System.Windows.Data;
+
+namespace CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.Converter
+{
+    public class TitleConverter : IValueConverter
+    {
+        object IValueConverter.Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            return "CefSharp.OutOfProcess.Wpf.OffscreenHost.Example - " + (value ?? "No Title Specified");
+        }
+
+        object IValueConverter.ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            return Binding.DoNothing;
+        }
+    }
+}
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/MainWindow.xaml b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/MainWindow.xaml
new file mode 100644
index 0000000..b342b39
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/MainWindow.xaml
@@ -0,0 +1,85 @@
+<Window x:Class="CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.MainWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:behaviors="http://schemas.microsoft.com/xaml/behaviors"
+        xmlns:offscreenhost="clr-namespace:CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.Behaviours"
+        FocusManager.FocusedElement="{Binding ElementName=Browser}"
+        mc:Ignorable="d"
+        Title="MainWindow" Height="768" Width="1024">
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+        <Grid>
+            <Grid.Resources>
+                <Style TargetType="{x:Type Button}">
+                    <Setter Property="Margin" Value="2,5" />
+                </Style>
+                <Style TargetType="{x:Type TextBox}">
+                    <Setter Property="Margin" Value="2,5" />
+                </Style>
+            </Grid.Resources>
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto" />
+                <ColumnDefinition Width="Auto" />
+                <ColumnDefinition />
+                <ColumnDefinition Width="Auto" />
+                <ColumnDefinition Width="Auto" />
+                <ColumnDefinition Width="Auto" />
+            </Grid.ColumnDefinitions>
+            <Button Content="Back" Command="{Binding WebBrowser.BackCommand, ElementName=Browser}" Width="50"/>
+            <Button Content="Forward" Command="{Binding WebBrowser.ForwardCommand, ElementName=Browser}" Grid.Column="1" Width="60"/>
+            <TextBox x:Name="txtBoxAddress" Text="{Binding Address, ElementName=Browser, FallbackValue=www.google.com}" Grid.Column="2" FontSize="12" BorderBrush="Gray" BorderThickness="1">
+                <!--<behaviors:Interaction.Behaviors>
+                    <offscreenhost:HoverLinkBehaviour />
+                </behaviors:Interaction.Behaviors>-->
+            </TextBox>
+            <Button Content="Print..." Command="{Binding WebBrowser.PrintCommand, ElementName=Browser}" Grid.Column="3" Width="50" />
+            <Button Content="View source" Command="{Binding WebBrowser.ViewSourceCommand, ElementName=Browser}" Grid.Column="4" Width="75" />
+            <Button Content="Show DevTools" Click="ShowDevToolsClick" Grid.Column="5" Width="100" />
+        </Grid>
+        <Border Grid.Row="1" BorderBrush="Gray" BorderThickness="0,1">
+            <ContentPresenter x:Name="BrowserContentPresenter" />
+            <!--<Offscreenhost:ChromiumWebBrowser x:Name="Browser"
+                                    Address="https://www.google.com">
+                <behaviors:Interaction.Behaviors>
+                    <behaviours:HoverLinkBehaviour x:Name="HoverLinkBehaviour"/>
+                </behaviors:Interaction.Behaviors>
+            </Offscreenhost:ChromiumWebBrowser>-->
+        </Border>
+        <ProgressBar IsIndeterminate="{Binding IsLoading, ElementName=Browser}"
+                     HorizontalAlignment="Stretch"
+                     VerticalAlignment="Top"
+                     Width="Auto"
+                     Grid.Row="1"
+                     Height="2"
+                     Visibility="{Binding IsLoading, ElementName=Browser, Converter={StaticResource BooleanToVisibilityConverter}}"
+                     BorderThickness="0" />
+        <StatusBar Grid.Row="2" HorizontalAlignment="Stretch" HorizontalContentAlignment="Stretch">
+            <StatusBar.ItemsPanel>
+                <ItemsPanelTemplate>
+                    <Grid>
+                        <Grid.ColumnDefinitions>
+                            <ColumnDefinition Width="*" />
+                            <ColumnDefinition Width="Auto" />
+                            <ColumnDefinition Width="Auto" />
+                        </Grid.ColumnDefinitions>
+                    </Grid>
+                </ItemsPanelTemplate>
+            </StatusBar.ItemsPanel>
+            <StatusBarItem Grid.Column="0">
+                <TextBlock Text="{Binding HoverLink, ElementName=HoverLinkBehaviour}" Grid.Column="2" HorizontalAlignment="Stretch" VerticalAlignment="Center" />
+            </StatusBarItem>
+            <Separator Grid.Column="1" />
+            <StatusBarItem Grid.Column="2">
+                <TextBlock HorizontalAlignment="Right" TextAlignment="Right" Grid.Column="3" VerticalAlignment="Center">
+                    Environment: <Run Text="{Binding Converter={StaticResource EnvironmentConverter}, Mode=OneTime}"/>
+                </TextBlock>
+            </StatusBarItem>
+        </StatusBar>
+    </Grid>
+</Window>
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/MainWindow.xaml.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/MainWindow.xaml.cs
new file mode 100644
index 0000000..64bfdd2
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/MainWindow.xaml.cs
@@ -0,0 +1,52 @@
+using System;
+using System.IO;
+using System.Windows;
+
+namespace CefSharp.OutOfProcess.Wpf.OffscreenHost.Example
+{
+    /// <summary>
+    /// Interaction logic for MainWindow.xaml
+    /// </summary>
+    public partial class MainWindow : Window
+    {
+#if DEBUG
+        private string _buildType = "Debug";
+#else
+        private string _buildType = "Release";
+#endif
+
+        #if NETCOREAPP3_1_OR_GREATER
+        private string _targetFramework = "netcoreapp3.1";
+        #else
+        private string _targetFramework = "net462";
+        #endif
+
+        private OutOfProcessHost _outOfProcessHost;
+
+        public MainWindow()
+        {
+            InitializeComponent();
+
+            Loaded += OnMainWindowLoaded;
+        }
+
+        private async void OnMainWindowLoaded(object sender, RoutedEventArgs e)
+        {
+
+            var outOfProcessHostPath = Path.GetFullPath($"..\\..\\..\\..\\CefSharp.OutOfProcess.BrowserProcess\\bin\\{_buildType}\\{_targetFramework}");
+            outOfProcessHostPath = Path.Combine(outOfProcessHostPath, OutOfProcessHost.HostExeName);
+            var cachePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "CefSharp\\OutOfProcessCache");
+
+            _outOfProcessHost = await OutOfProcessHost.CreateAsync(outOfProcessHostPath, cachePath, true);
+
+            var browser = new OffscreenChromiumWebBrowser(_outOfProcessHost, "https://www.google.com");
+            BrowserContentPresenter.Content = browser;
+
+        }
+
+        private void ShowDevToolsClick(object sender, RoutedEventArgs e)
+        {
+            
+        }
+    }
+}
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/app.manifest b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/app.manifest
new file mode 100644
index 0000000..8db82df
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/app.manifest
@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity version="1.0.0.0" name="CefSharp.Wpf.HwndHost.Example.app"/>
+  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
+    <security>
+      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
+        <!-- UAC Manifest Options
+             If you want to change the Windows User Account Control level replace the 
+             requestedExecutionLevel node with one of the following.
+
+        <requestedExecutionLevel  level="asInvoker" uiAccess="false" />
+        <requestedExecutionLevel  level="requireAdministrator" uiAccess="false" />
+        <requestedExecutionLevel  level="highestAvailable" uiAccess="false" />
+
+            Specifying requestedExecutionLevel element will disable file and registry virtualization. 
+            Remove this element if your application requires this virtualization for backwards
+            compatibility.
+        -->
+        <requestedExecutionLevel level="asInvoker" uiAccess="false" />
+      </requestedPrivileges>
+    </security>
+  </trustInfo>
+
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <!-- A list of the Windows versions that this application has been tested on
+           and is designed to work with. Uncomment the appropriate elements
+           and Windows will automatically select the most compatible environment. -->
+
+      <!-- Windows 7 -->
+      <supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}" />
+
+      <!-- Windows 8 -->
+      <supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}" />
+
+      <!-- Windows 8.1 -->
+      <supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}" />
+
+      <!-- Windows 10 -->
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
+
+    </application>
+  </compatibility>
+
+  <!-- Indicates that the application is DPI-aware and will not be automatically scaled by Windows at higher
+       DPIs. Windows Presentation Foundation (WPF) applications are automatically DPI-aware and do not need 
+       to opt in. Windows Forms applications targeting .NET Framework 4.6 that opt into this setting, should 
+       also set the 'EnableWindowsFormsHighDpiAutoResizing' setting to 'true' in their app.config. -->
+
+  <application xmlns="urn:schemas-microsoft-com:asm.v3">
+    <windowsSettings>
+      <!-- The combination of below two tags have the following effect : 
+      1) Per-MonitorV2 for >= Windows 10 Anniversary Update
+      2) PerMonitor < Windows 10 Anniversary Update -->
+      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
+      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/PM</dpiAware>
+    </windowsSettings>
+  </application>
+
+
+  <!-- Enable themes for Windows common controls and dialogs (Windows XP and later) -->
+
+  <dependency>
+    <dependentAssembly>
+      <assemblyIdentity
+          type="win32"
+          name="Microsoft.Windows.Common-Controls"
+          version="6.0.0.0"
+          processorArchitecture="*"
+          publicKeyToken="6595b64144ccf1df"
+          language="*"
+        />
+    </dependentAssembly>
+  </dependency>
+
+
+</assembly>
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharp.OutOfProcess.Wpf.OffscreenHost.csproj b/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharp.OutOfProcess.Wpf.OffscreenHost.csproj
new file mode 100644
index 0000000..fa0b1d8
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharp.OutOfProcess.Wpf.OffscreenHost.csproj
@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>net462;netcoreapp3.1</TargetFrameworks>
+    <UseWPF>true</UseWPF>
+    <IsPackable>true</IsPackable>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="PInvoke.Kernel32" Version="0.7.124" />
+    <PackageReference Include="PInvoke.User32" Version="0.7.124" />
+    <PackageReference Include="StreamJsonRpc" Version="2.13.33" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\CefSharp.OutOfProcess.Core\CefSharp.OutOfProcess.Core.csproj" PrivateAssets="All" />
+    <ProjectReference Include="..\CefSharp.OutOfProcess.Interface\CefSharp.OutOfProcess.Interface.csproj" PrivateAssets="All" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="$(OutputPath)\$(TargetFrameworks)\CefSharp.OutOfProcess.Core.*">
+      <Pack>true</Pack>
+      <PackagePath>lib\$(TargetFrameworks)</PackagePath>
+    </Content>
+    <Content Include="$(OutputPath)\$(TargetFrameworks)\CefSharp.OutOfProcess.Interface.*">
+      <Pack>true</Pack>
+      <PackagePath>lib\$(TargetFrameworks)</PackagePath>
+    </Content>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/AbstractRenderHandler.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/AbstractRenderHandler.cs
new file mode 100644
index 0000000..08ce808
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/AbstractRenderHandler.cs
@@ -0,0 +1,129 @@
+// Copyright © 2019 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+using System;
+using System.IO.MemoryMappedFiles;
+using System.Threading;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Threading;
+
+namespace CefSharp.Wpf.Rendering
+{
+    /// <summary>
+    /// Implements the basics of a <see cref="IRenderHandler"/>
+    /// </summary>
+    /// <seealso cref="CefSharp.Wpf.IRenderHandler" />
+    public abstract class AbstractRenderHandler : IDisposable
+    {
+        internal static readonly PixelFormat PixelFormat = PixelFormats.Pbgra32;
+        internal static int BytesPerPixel = PixelFormat.BitsPerPixel / 8;
+
+        protected object lockObject = new object();
+
+        protected Size viewSize;
+        protected Size popupSize;
+        protected DispatcherPriority dispatcherPriority;
+
+        protected MemoryMappedFile viewMemoryMappedFile;
+        protected MemoryMappedFile popupMemoryMappedFile;
+        protected MemoryMappedViewAccessor viewMemoryMappedViewAccessor;
+        protected MemoryMappedViewAccessor popupMemoryMappedViewAccessor;
+
+        /// <summary>
+        /// The value for disposal, if it's 1 (one) then this instance is either disposed
+        /// or in the process of getting disposed
+        /// </summary>
+        private int disposeSignaled;
+
+        /// <summary>
+        /// Gets a value indicating whether this instance is disposed.
+        /// </summary>
+        /// <value><see langword="true"/> if this instance is disposed; otherwise, <see langword="true"/>.</value>
+        public bool IsDisposed
+        {
+            get
+            {
+                return Interlocked.CompareExchange(ref disposeSignaled, 1, 1) == 1;
+            }
+        }
+
+        /// <summary>
+        /// Releases all resources used by the <see cref="AbstractRenderHandler"/> object
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources for the <see cref="AbstractRenderHandler"/>
+        /// </summary>
+        /// <param name="disposing"><see langword="true" /> to release both managed and unmanaged resources; <see langword="false" /> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (Interlocked.CompareExchange(ref disposeSignaled, 1, 0) != 0)
+            {
+                return;
+            }
+
+            if (!disposing)
+            {
+                return;
+            }
+
+            lock (lockObject)
+            {
+                ReleaseMemoryMappedView(ref popupMemoryMappedFile, ref popupMemoryMappedViewAccessor);
+                ReleaseMemoryMappedView(ref viewMemoryMappedFile, ref viewMemoryMappedViewAccessor);
+            }
+        }
+
+        protected void ReleaseMemoryMappedView(ref MemoryMappedFile mappedFile, ref MemoryMappedViewAccessor stream)
+        {
+            if (stream != null)
+            {
+                stream.Dispose();
+                stream = null;
+            }
+
+            if (mappedFile != null)
+            {
+                mappedFile.Dispose();
+                mappedFile = null;
+            }
+        }
+
+        /// <summary>
+        /// Called when an element should be painted. (Invoked from CefRenderHandler.OnPaint)
+        /// This method is only called when <see cref="IWindowInfo.SharedTextureEnabled"/> is set to false.
+        /// </summary>
+        /// <param name="isPopup">indicates whether the element is the view or the popup widget.</param>
+        /// <param name="dirtyRect">contains the set of rectangles in pixel coordinates that need to be repainted</param>
+        /// <param name="buffer">The bitmap will be will be  width * height *4 bytes in size and represents a BGRA image with an upper-left origin</param>
+        /// <param name="width">width</param>
+        /// <param name="height">height</param>
+        /// <param name="image">image used as parent for rendered bitmap</param>
+        public virtual void OnPaint(bool isPopup, CefSharp.OutOfProcess.Interface.Rect dirtyRect, IntPtr buffer, byte[] data, int width, int height, Image image)
+        {
+            if (IsDisposed || image.Dispatcher.HasShutdownStarted)
+            {
+                return;
+            }
+
+            if (isPopup)
+            {
+                CreateOrUpdateBitmap(isPopup, dirtyRect, buffer, width, height, image, ref popupSize, ref popupMemoryMappedFile, ref popupMemoryMappedViewAccessor);
+            }
+            else
+            {
+                CreateOrUpdateBitmap(isPopup, dirtyRect, buffer, width, height, image, ref viewSize, ref viewMemoryMappedFile, ref viewMemoryMappedViewAccessor);
+            }
+        }
+
+        protected abstract void CreateOrUpdateBitmap(bool isPopup, CefSharp.OutOfProcess.Interface.Rect dirtyRect, IntPtr buffer, int width, int height, Image image, ref Size currentSize, ref MemoryMappedFile mappedFile, ref MemoryMappedViewAccessor viewAccessor);
+    }
+}
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/DirectWritableBitmapRenderHandler.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/DirectWritableBitmapRenderHandler.cs
new file mode 100644
index 0000000..213d0ea
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/DirectWritableBitmapRenderHandler.cs
@@ -0,0 +1,132 @@
+// Copyright © 2020 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+//NOTE:Classes in the CefSharp.Core namespace have been hidden from intellisnse so users don't use them directly
+
+namespace CefSharp.Wpf.Rendering
+{
+    using System;
+    using System.IO.MemoryMappedFiles;
+    using System.Runtime.InteropServices;
+    using System.Windows;
+    using System.Windows.Controls;
+    using System.Windows.Media;
+    using System.Windows.Media.Imaging;
+    using System.Windows.Threading;
+    using Rect = CefSharp.OutOfProcess.Interface.Rect;
+
+    /// <summary>
+    /// DirectWritableBitmapRenderHandler - directly copyies the buffer
+    /// into writeableBitmap.BackBuffer. No additional copies or locking are used.
+    /// Can only be used when CEF UI thread and WPF UI thread are the same (MultiThreadedMessageLoop = false).
+    /// </summary>
+    public sealed class DirectWritableBitmapRenderHandler : IDisposable
+    {
+        private readonly double dpiX;
+        private readonly double dpiY;
+        private readonly bool invalidateDirtyRect;
+
+        private MemoryMappedFile mappedFile;
+        private MemoryMappedViewAccessor viewAccessor;
+        private string currentFile;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DirectWritableBitmapRenderHandler"/> class.
+        /// </summary>
+        /// <param name="dpiX">The dpi x.</param>
+        /// <param name="dpiY">The dpi y.</param>
+        /// <param name="invalidateDirtyRect">if true then only the direct rectangle will be updated, otherwise the whole bitmap will be redrawn.</param>
+        /// <param name="dispatcherPriority">priority at which the bitmap will be updated on the UI thread.</param>
+        public DirectWritableBitmapRenderHandler(double dpiX, double dpiY, bool invalidateDirtyRect = false, DispatcherPriority dispatcherPriority = DispatcherPriority.Render)
+        {
+            this.dpiX = dpiX;
+            this.dpiY = dpiY;
+            this.invalidateDirtyRect = invalidateDirtyRect;
+        }
+
+        /// <summary>
+        /// Is called when source bitmap updates and transfers the content to the image control.
+        /// </summary>
+        /// <param name="dirtyRect">if only a part has been rerendered, this rect defines the rerendered subpart.</param>
+        /// <param name="width">width of the bitmap.</param>
+        /// <param name="height">height of the bitmap.</param>
+        /// <param name="image">image to be paint on.</param>
+        /// <param name="file">filename of a memorymappedfile containing the bitmap to be paint.</param>
+        public void OnPaint(Rect dirtyRect, int width, int height, Image image, string file)
+        {
+            const int sizeInfoOffset = 2 * sizeof(int);
+            var stride = width * 4;
+            var noOfBytes = stride * height;
+            if (currentFile != file)
+            {
+                viewAccessor?.Dispose();
+                mappedFile?.Dispose();
+                try
+                {
+                    mappedFile = MemoryMappedFile.OpenExisting(file);
+                    viewAccessor = mappedFile.CreateViewAccessor(0, noOfBytes + sizeInfoOffset, MemoryMappedFileAccess.Read);
+                    currentFile = file;
+                }
+                catch (Exception)
+                {
+                }
+            }
+
+            if (viewAccessor == null)
+            {
+                return;
+            }
+
+            var ptr = viewAccessor.SafeMemoryMappedViewHandle.DangerousGetHandle();
+            if (ptr == IntPtr.Zero)
+            {
+                return;
+            }
+
+            int data_width = Marshal.ReadInt32(ptr);
+            int data_height = Marshal.ReadInt32(ptr + sizeof(int));
+
+            stride = data_width * 4;
+            noOfBytes = stride * data_height;
+
+            if (!(image.Source is WriteableBitmap writeableBitmap) || writeableBitmap.PixelWidth != data_width || writeableBitmap.PixelHeight != data_height)
+            {
+                image.SetCurrentValue(Image.SourceProperty, writeableBitmap = new WriteableBitmap(data_width, data_height, dpiX, dpiY, PixelFormats.Pbgra32, null));
+            }
+
+            if (writeableBitmap != null)
+            {
+                writeableBitmap.Lock();
+
+                if (invalidateDirtyRect)
+                {
+                    // Update the dirty region
+                    var sourceRect = new Int32Rect(dirtyRect.X, dirtyRect.Y, dirtyRect.Width, dirtyRect.Height);
+
+                    writeableBitmap.Lock();
+                    writeableBitmap.WritePixels(sourceRect, ptr + sizeInfoOffset, noOfBytes, writeableBitmap.BackBufferStride, dirtyRect.X, dirtyRect.Y);
+                    writeableBitmap.Unlock();
+                }
+                else
+                {
+                    // Update whole bitmap
+                    var sourceRect = new Int32Rect(0, 0, data_width, data_height);
+
+                    writeableBitmap.Lock();
+                    writeableBitmap.WritePixels(sourceRect, ptr + sizeInfoOffset, noOfBytes, writeableBitmap.BackBufferStride);
+                    writeableBitmap.Unlock();
+                }
+
+                writeableBitmap.Unlock();
+            }
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+            viewAccessor?.Dispose();
+            mappedFile?.Dispose();
+        }
+    }
+}
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/NativeMethodWrapper.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/NativeMethodWrapper.cs
new file mode 100644
index 0000000..5402e90
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/NativeMethodWrapper.cs
@@ -0,0 +1,32 @@
+// Copyright © 2020 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+//NOTE:Classes in the CefSharp.Core namespace have been hidden from intellisnse so users don't use them directly
+
+using System;
+
+namespace CefSharp
+{
+    /// <summary>
+    /// Native static methods for low level operations, memory copy
+    /// Avoids having to P/Invoke as we can call the C++ API directly.
+    /// </summary>
+    public static class NativeMethodWrapper
+    {
+        public static void MemoryCopy(IntPtr dest, IntPtr src, int numberOfBytes)
+        {
+            PInvoke.Kernel32.CopyMemory(dest, src, new IntPtr(numberOfBytes));
+        }
+
+        public static void SetWindowPosition(IntPtr handle, int x, int y, int width, int height)
+        {
+            PInvoke.User32.SetWindowPos(handle, handle - 2, x, y, width, height, 0);
+        }
+
+        public static void SetWindowParent(IntPtr child, IntPtr newParent)
+        {
+            PInvoke.User32.SetParent(child, newParent);
+        }
+    }
+}
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/RectStruct.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/RectStruct.cs
new file mode 100644
index 0000000..81d1ab4
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/RectStruct.cs
@@ -0,0 +1,47 @@
+// Copyright © 2018 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+using System.Runtime.InteropServices;
+
+namespace CefSharp.Wpf.Internals
+{
+    /// <summary>
+    /// The RECT structure defines the coordinates of the upper-left and lower-right corners of a rectangle.
+    /// </summary>
+    /// <see cref="https://docs.microsoft.com/en-us/previous-versions/dd162897(v=vs.85)"/>
+    /// <remarks>
+    /// By convention, the right and bottom edges of the rectangle are normally considered exclusive. 
+    /// In other words, the pixel whose coordinates are ( right, bottom ) lies immediately outside of the the rectangle. 
+    /// For example, when RECT is passed to the FillRect function, the rectangle is filled up to, but not including, 
+    /// the right column and bottom row of pixels. This structure is identical to the RECTL structure.
+    /// </remarks>
+    [StructLayout(LayoutKind.Sequential)]
+    public struct RectStruct
+    {
+        /// <summary>
+        /// The x-coordinate of the upper-left corner of the rectangle.
+        /// </summary>
+        public int Left;
+
+        /// <summary>
+        /// The y-coordinate of the upper-left corner of the rectangle.
+        /// </summary>
+        public int Top;
+
+        /// <summary>
+        /// The x-coordinate of the lower-right corner of the rectangle.
+        /// </summary>
+        public int Right;
+
+        /// <summary>
+        /// The y-coordinate of the lower-right corner of the rectangle.
+        /// </summary>
+        public int Bottom;
+
+        public static implicit operator CefSharp.OutOfProcess.Interface.Rect(RectStruct rect)
+        {
+            return new CefSharp.OutOfProcess.Interface.Rect(0, 0, rect.Right - rect.Left, rect.Bottom - rect.Top);
+        }
+    }
+}
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/WPFExtensions.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/WPFExtensions.cs
new file mode 100644
index 0000000..f4e941f
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/WPFExtensions.cs
@@ -0,0 +1,244 @@
+// Copyright © 2015 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+using System.IO;
+using System.Text;
+using System.Windows;
+using System.Windows.Input;
+using CefSharp.OutOfProcess;
+
+namespace CefSharp.Wpf.Internals
+{
+    /// <summary>
+    /// Internal WpfExtension methods - unlikely you'd need to use these,
+    /// they're left public on the off chance you do.
+    /// </summary>
+    public static class WpfExtensions
+    {
+        /// <summary>
+        /// TODO: (CEF) move to helper
+        /// </summary>
+        /// <param name="e"></param>
+        /// <returns></returns>
+        public static Dom.Input.MouseButton GetButton(this MouseButtonEventArgs e)
+        {
+            Dom.Input.MouseButton buttonState = Dom.Input.MouseButton.None;
+            if (e.ChangedButton == MouseButton.Left)
+            {
+                buttonState = Dom.Input.MouseButton.Left;
+            }
+            else if (e.ChangedButton == MouseButton.Right)
+            {
+                buttonState = Dom.Input.MouseButton.Right;
+            }
+            else if (e.ChangedButton == MouseButton.Middle)
+            {
+                buttonState = Dom.Input.MouseButton.Middle;
+            }
+
+            return buttonState;
+        }
+
+        /// <summary>
+        /// Gets the modifiers.
+        /// </summary>
+        /// <param name="e">The <see cref="MouseEventArgs"/> instance containing the event data.</param>
+        /// <returns>CefEventFlags.</returns>
+        public static CefEventFlags GetModifiers(this MouseEventArgs e)
+        {
+            CefEventFlags modifiers = 0;
+
+            if (e.LeftButton == MouseButtonState.Pressed)
+            {
+                modifiers |= CefEventFlags.LeftMouseButton;
+            }
+            if (e.MiddleButton == MouseButtonState.Pressed)
+            {
+                modifiers |= CefEventFlags.MiddleMouseButton;
+            }
+            if (e.RightButton == MouseButtonState.Pressed)
+            {
+                modifiers |= CefEventFlags.RightMouseButton;
+            }
+
+            modifiers |= GetModifierKeys(modifiers);
+
+            return modifiers;
+        }
+
+        /// <summary>
+        /// Gets keyboard modifiers.
+        /// </summary>
+        /// <returns>CefEventFlags.</returns>
+        public static CefEventFlags GetModifierKeys(CefEventFlags modifiers = 0)
+        {
+            if (Keyboard.IsKeyDown(Key.LeftCtrl))
+            {
+                modifiers |= CefEventFlags.ControlDown | CefEventFlags.IsLeft;
+            }
+
+            if (Keyboard.IsKeyDown(Key.RightCtrl))
+            {
+                modifiers |= CefEventFlags.ControlDown | CefEventFlags.IsRight;
+            }
+
+            if (Keyboard.IsKeyDown(Key.LeftShift))
+            {
+                modifiers |= CefEventFlags.ShiftDown | CefEventFlags.IsLeft;
+            }
+
+            if (Keyboard.IsKeyDown(Key.RightShift))
+            {
+                modifiers |= CefEventFlags.ShiftDown | CefEventFlags.IsRight;
+            }
+
+            if (Keyboard.IsKeyDown(Key.LeftAlt))
+            {
+                modifiers |= CefEventFlags.AltDown | CefEventFlags.IsLeft;
+            }
+
+            if (Keyboard.IsKeyDown(Key.RightAlt))
+            {
+                modifiers |= CefEventFlags.AltDown | CefEventFlags.IsRight;
+            }
+
+            return modifiers;
+        }
+
+        /// <summary>
+        /// Gets the modifiers.
+        /// </summary>
+        /// <param name="e">The <see cref="KeyEventArgs"/> instance containing the event data.</param>
+        /// <returns>CefEventFlags.</returns>
+        public static CefEventFlags GetModifiers(this KeyEventArgs e)
+        {
+            CefEventFlags modifiers = 0;
+
+            //Only read modifiers once for performance reasons
+            //https://referencesource.microsoft.com/#PresentationCore/Core/CSharp/System/Windows/Input/KeyboardDevice.cs,227
+            var keyboardDeviceModifiers = e.KeyboardDevice.Modifiers;
+
+            if (keyboardDeviceModifiers.HasFlag(ModifierKeys.Shift))
+            {
+                modifiers |= CefEventFlags.ShiftDown;
+            }
+
+            if (keyboardDeviceModifiers.HasFlag(ModifierKeys.Alt))
+            {
+                modifiers |= CefEventFlags.AltDown;
+            }
+
+            if (keyboardDeviceModifiers.HasFlag(ModifierKeys.Control))
+            {
+                modifiers |= CefEventFlags.ControlDown;
+            }
+
+            return modifiers;
+        }
+
+        //// TODO: (CEF)
+        /////// <summary>
+        /////// Gets the drag data wrapper.
+        /////// </summary>
+        /////// <param name="e">The <see cref="DragEventArgs"/> instance containing the event data.</param>
+        /////// <returns>CefDragDataWrapper.</returns>
+        ////public static IDragData GetDragData(this DragEventArgs e)
+        ////{
+        ////    // Convert Drag Data
+        ////    var dragData = DragData.Create();
+
+        ////    // Files            
+        ////    dragData.IsFile = e.Data.GetDataPresent(DataFormats.FileDrop);
+        ////    if (dragData.IsFile)
+        ////    {
+        ////        // As per documentation, we only need to specify FileNames, not FileName, when dragging into the browser (http://magpcss.org/ceforum/apidocs3/projects/(default)/CefDragData.html)
+        ////        foreach (var filePath in (string[])e.Data.GetData(DataFormats.FileDrop))
+        ////        {
+        ////            var displayName = Path.GetFileName(filePath);
+
+        ////            dragData.AddFile(filePath.Replace("\\", "/"), displayName);
+        ////        }
+        ////    }
+
+        ////    // Link/Url
+        ////    var link = GetLink(e.Data);
+        ////    dragData.IsLink = !string.IsNullOrEmpty(link);
+        ////    if (dragData.IsLink)
+        ////    {
+        ////        dragData.LinkUrl = link;
+        ////    }
+
+        ////    // Text/HTML
+        ////    dragData.IsFragment = e.Data.GetDataPresent(DataFormats.Text);
+        ////    if (dragData.IsFragment)
+        ////    {
+        ////        dragData.FragmentText = (string)e.Data.GetData(DataFormats.Text);
+
+        ////        var htmlData = (string)e.Data.GetData(DataFormats.Html);
+        ////        if (htmlData != String.Empty)
+        ////        {
+        ////            dragData.FragmentHtml = htmlData;
+        ////        }
+        ////    }
+
+        ////    return dragData;
+        ////}
+
+        /// <summary>
+        /// Gets the link.
+        /// </summary>
+        /// <param name="data">The data.</param>
+        /// <returns>System.String.</returns>
+        private static string GetLink(IDataObject data)
+        {
+            const string asciiUrlDataFormatName = "UniformResourceLocator";
+            const string unicodeUrlDataFormatName = "UniformResourceLocatorW";
+
+            // Try Unicode
+            if (data.GetDataPresent(unicodeUrlDataFormatName))
+            {
+                // Try to read a Unicode URL from the data
+                var unicodeUrl = ReadUrlFromDragDropData(data, unicodeUrlDataFormatName, Encoding.Unicode);
+                if (unicodeUrl != null)
+                {
+                    return unicodeUrl;
+                }
+            }
+
+            // Try ASCII
+            if (data.GetDataPresent(asciiUrlDataFormatName))
+            {
+                // Try to read an ASCII URL from the data
+                return ReadUrlFromDragDropData(data, asciiUrlDataFormatName, Encoding.ASCII);
+            }
+
+            // Not a valid link
+            return null;
+        }
+
+        /// <summary>
+        /// Reads a URL using a particular text encoding from drag-and-drop data.
+        /// </summary>
+        /// <param name="data">The drag-and-drop data.</param>
+        /// <param name="urlDataFormatName">The data format name of the URL type.</param>
+        /// <param name="urlEncoding">The text encoding of the URL type.</param>
+        /// <returns>A URL, or <see langword="null" /> if <paramref name="data" /> does not contain a URL
+        /// of the correct type.</returns>
+        private static string ReadUrlFromDragDropData(IDataObject data, string urlDataFormatName, Encoding urlEncoding)
+        {
+            // Read the URL from the data
+            string url;
+            using (var urlStream = (Stream)data.GetData(urlDataFormatName))
+            {
+                using (TextReader reader = new StreamReader(urlStream, urlEncoding))
+                {
+                    url = reader.ReadToEnd();
+                }
+            }
+
+            // URLs in drag/drop data are often padded with null characters so remove these
+            return url.TrimEnd('\0');
+        }
+    }
+}
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/WritableBitmapRenderHandler.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/WritableBitmapRenderHandler.cs
new file mode 100644
index 0000000..179af97
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost/CefSharpWPF/WritableBitmapRenderHandler.cs
@@ -0,0 +1,150 @@
+// Copyright © 2018 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+using System;
+using System.IO.MemoryMappedFiles;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Threading;
+
+namespace CefSharp.Wpf.Rendering
+{
+    /// <summary>
+    /// WritableBitmapRenderHandler - creates/updates an WritableBitmap
+    /// Uses a MemoryMappedFile for double buffering when the size matches
+    /// or creates a new WritableBitmap when required
+    /// </summary>
+    /// <seealso cref="CefSharp.Wpf.IRenderHandler" />
+    public class WritableBitmapRenderHandler : AbstractRenderHandler
+    {
+        private readonly double dpiX;
+        private readonly double dpiY;
+        private readonly bool invalidateDirtyRect;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="WritableBitmapRenderHandler"/> class.
+        /// </summary>
+        /// <param name="dpiX">The dpi x.</param>
+        /// <param name="dpiY">The dpi y.</param>
+        /// <param name="invalidateDirtyRect">if true then only the direct rectangle will be updated, otherwise the whole bitmap will be redrawn</param>
+        /// <param name="dispatcherPriority">priority at which the bitmap will be updated on the UI thread</param>
+        public WritableBitmapRenderHandler(double dpiX, double dpiY, bool invalidateDirtyRect = true, DispatcherPriority dispatcherPriority = DispatcherPriority.Render)
+        {
+            this.dpiX = dpiX;
+            this.dpiY = dpiY;
+            this.invalidateDirtyRect = invalidateDirtyRect;
+            this.dispatcherPriority = dispatcherPriority;
+        }
+
+        protected override void CreateOrUpdateBitmap(bool isPopup, CefSharp.OutOfProcess.Interface.Rect dirtyRect, IntPtr buffer, int width, int height, Image image, ref Size currentSize, ref MemoryMappedFile mappedFile, ref MemoryMappedViewAccessor viewAccessor)
+        {
+            bool createNewBitmap = false;
+
+            lock (lockObject)
+            {
+                int pixels = width * height;
+                int numberOfBytes = pixels * BytesPerPixel;
+
+                createNewBitmap = mappedFile == null || currentSize.Height != height || currentSize.Width != width;
+
+                if (createNewBitmap)
+                {
+                    //If the MemoryMappedFile is smaller than we need then create a larger one
+                    //If it's larger then we need then rather than going through the costly expense of
+                    //allocating a new one we'll just use the old one and only access the number of bytes we require.
+                    if (viewAccessor == null || viewAccessor.Capacity < numberOfBytes)
+                    {
+                        ReleaseMemoryMappedView(ref mappedFile, ref viewAccessor);
+
+                        mappedFile = MemoryMappedFile.CreateNew(null, numberOfBytes, MemoryMappedFileAccess.ReadWrite);
+
+                        viewAccessor = mappedFile.CreateViewAccessor();
+                    }
+
+                    currentSize.Height = height;
+                    currentSize.Width = width;
+                }
+
+                NativeMethodWrapper.MemoryCopy(viewAccessor.SafeMemoryMappedViewHandle.DangerousGetHandle(), buffer, numberOfBytes);
+
+                //Take a reference to the sourceBuffer that's used to update our WritableBitmap,
+                //once we're on the UI thread we need to check if it's still valid
+                var sourceBuffer = viewAccessor.SafeMemoryMappedViewHandle;
+
+                image.Dispatcher.BeginInvoke((Action)(() =>
+                {
+                    lock (lockObject)
+                    {
+                        if (sourceBuffer.IsClosed || sourceBuffer.IsInvalid)
+                        {
+                            return;
+                        }
+
+                        var size = isPopup ? popupSize : viewSize;
+
+                        //If OnPaint is called multiple times before
+                        //our BeginInvoke call we check the size matches our most recent
+                        //update, the buffer has already been overriden (frame is dropped effectively)
+                        //so we ignore this call
+                        //https://github.com/cefsharp/CefSharp/issues/3114
+                        if (size.Width != width || size.Height != height)
+                        {
+                            return;
+                        }
+
+                        if (createNewBitmap)
+                        {
+                            if (image.Source != null)
+                            {
+                                image.Source = null;
+                                GC.Collect(1);
+                            }
+
+                            image.Source = new WriteableBitmap(width, height, dpiX, dpiY, PixelFormat, null);
+                        }
+
+                        var stride = width * BytesPerPixel;
+                        var noOfBytes = stride * height;
+
+                        var bitmap = (WriteableBitmap)image.Source;
+
+                        //When agressively resizing the ChromiumWebBrowser sometimes
+                        //we can end up with our buffer size not matching our bitmap size
+                        //Just ignore these frames as the rendering should eventually catch up
+                        //(CEF can generate multiple frames before WPF has performed a render cycle)
+                        //https://github.com/cefsharp/CefSharp/issues/3474
+                        if (width > bitmap.PixelWidth || height > bitmap.PixelHeight)
+                        {
+                            return;
+                        }
+
+                        //By default we'll only update the dirty rect, for those that run into a MILERR_WIN32ERROR Exception (#2035)
+                        //it's desirably to either upgrade to a newer .Net version (only client runtime needs to be installed, not compiled
+                        //against a newer version. Or invalidate the whole bitmap
+                        if (invalidateDirtyRect)
+                        {
+                            // Update the dirty region
+                            var sourceRect = new Int32Rect(dirtyRect.X, dirtyRect.Y, dirtyRect.Width, dirtyRect.Height);
+
+                            bitmap.Lock();
+                            bitmap.WritePixels(sourceRect, sourceBuffer.DangerousGetHandle(), noOfBytes, stride, dirtyRect.X, dirtyRect.Y);
+                            bitmap.Unlock();
+                        }
+                        else
+                        {
+                            // Update whole bitmap
+                            var sourceRect = new Int32Rect(0, 0, width, height);
+
+                            bitmap.Lock();
+                            bitmap.WritePixels(sourceRect, sourceBuffer.DangerousGetHandle(), noOfBytes, stride);
+                            bitmap.Unlock();
+                        }
+                    }
+                }), dispatcherPriority);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost/Internals/DelegateCommand.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost/Internals/DelegateCommand.cs
new file mode 100644
index 0000000..17ff317
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost/Internals/DelegateCommand.cs
@@ -0,0 +1,68 @@
+// Copyright © 2019 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+using System;
+using System.Windows.Input;
+
+namespace CefSharp.OutOfProcess.Wpf.OffscreenHost.Internals
+{
+    /// <summary>
+    /// DelegateCommand
+    /// </summary>
+    /// <seealso cref="System.Windows.Input.ICommand" />
+    internal class DelegateCommand : ICommand
+    {
+        /// <summary>
+        /// The command handler
+        /// </summary>
+        private readonly Action commandHandler;
+        /// <summary>
+        /// The can execute handler
+        /// </summary>
+        private readonly Func<bool> canExecuteHandler;
+
+        /// <summary>
+        /// Occurs when changes occur that affect whether or not the command should execute.
+        /// </summary>
+        public event EventHandler CanExecuteChanged;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DelegateCommand"/> class.
+        /// </summary>
+        /// <param name="commandHandler">The command handler.</param>
+        /// <param name="canExecuteHandler">The can execute handler.</param>
+        public DelegateCommand(Action commandHandler, Func<bool> canExecuteHandler = null)
+        {
+            this.commandHandler = commandHandler;
+            this.canExecuteHandler = canExecuteHandler;
+        }
+
+        /// <summary>
+        /// Defines the method to be called when the command is invoked.
+        /// </summary>
+        /// <param name="parameter">Data used by the command.  If the command does not require data to be passed, this object can be set to null.</param>
+        public void Execute(object parameter)
+        {
+            commandHandler();
+        }
+
+        /// <summary>
+        /// Defines the method that determines whether the command can execute in its current state.
+        /// </summary>
+        /// <param name="parameter">Data used by the command.  If the command does not require data to be passed, this object can be set to null.</param>
+        /// <returns>true if this command can be executed; otherwise, false.</returns>
+        public bool CanExecute(object parameter)
+        {
+            return canExecuteHandler == null || canExecuteHandler();
+        }
+
+        /// <summary>
+        /// Raises the can execute changed.
+        /// </summary>
+        public void RaiseCanExecuteChanged()
+        {
+            CanExecuteChanged?.Invoke(this, EventArgs.Empty);
+        }
+    }
+}
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost/OffscreenChromiumWebBrowser.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost/OffscreenChromiumWebBrowser.cs
new file mode 100644
index 0000000..d20a6ed
--- /dev/null
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost/OffscreenChromiumWebBrowser.cs
@@ -0,0 +1,1182 @@
+// Copyright © 2022 The CefSharp Authors. All rights reserved.
+//
+// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
+
+using CefSharp.OutOfProcess.Internal;
+using System;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Windows;
+using System.Windows.Input;
+using System.Windows.Interop;
+using System.Windows.Threading;
+using Window = System.Windows.Window;
+using System.Windows.Controls;
+using CefSharp.Wpf.Rendering;
+using System.Windows.Media;
+using Application = System.Windows.Application;
+using System.Threading.Tasks;
+using CefSharp.Dom;
+using CefSharp.OutOfProcess.WinForms;
+using CefSharp.Wpf.Internals;
+using CefSharp.OutOfProcess.Wpf.OffscreenHost.Internals;
+using System.Collections.Generic;
+
+namespace CefSharp.OutOfProcess.Wpf.OffscreenHost
+{
+    /// <summary>
+    /// ChromiumWebBrowser is the WPF web browser control
+    /// </summary>
+    /// <seealso cref="Control" />
+    /// <seealso cref="Wpf.HwndHost.IWpfWebBrowser" />
+    /// based on https://docs.microsoft.com/en-us/dotnet/framework/wpf/advanced/walkthrough-hosting-a-win32-control-in-wpf
+    /// and https://stackoverflow.com/questions/6500336/custom-dwm-drawn-window-frame-flickers-on-resizing-if-the-window-contains-a-hwnd/17471534#17471534
+    public class OffscreenChromiumWebBrowser : Control, IChromiumWebBrowserInternal, IRenderHandlerInternal
+    {
+        private const string BrowserNotInitializedExceptionErrorMessage =
+            "The ChromiumWebBrowser instance creates the underlying Chromium Embedded Framework (CEF) browser instance in an async fashion. " +
+            "The undelying CefBrowser instance is not yet initialized. Use the IsBrowserInitializedChanged event and check " +
+            "the IsBrowserInitialized property to determine when the browser has been initialized.";
+
+        private readonly Dictionary<string, string> _keyMapping = new Dictionary<string, string>() {
+            { "Left", "ArrowLeft" },
+            { "Right", "ArrowRight" },
+            { "Up", "ArrowUp" },
+            { "Down", "ArrowDown" },
+            { "Tab", "Tab" },
+        };
+
+        /// <summary>
+        /// The image that represents this browser instances
+        /// </summary>
+        private readonly Image _image = new Image();
+
+        /// <summary>
+        /// The popup image
+        /// </summary>
+        private readonly Image _popupImage = new Image();
+
+        private readonly OutOfProcessHost _host;
+        private IntPtr _browserHwnd = IntPtr.Zero;
+
+        private readonly OutOfProcessConnectionTransport _devToolsContextConnectionTransport;
+        private readonly IDevToolsContext _devToolsContext;
+        private readonly int _id;
+        private bool _devToolsReady;
+
+        /// <summary>
+        /// The ignore URI change
+        /// </summary>
+        private bool _ignoreUriChange;
+        /// <summary>
+        /// Initial address
+        /// </summary>
+        private readonly string _initialAddress;
+
+        /// <summary>
+        /// The browser initialized - boolean represented as 0 (false) and 1(true) as we use Interlocker to increment/reset
+        /// </summary>
+        private int _browserInitialized;
+
+        /// <summary>
+        /// The value for disposal, if it's 1 (one) then this instance is either disposed
+        /// or in the process of getting disposed
+        /// </summary>
+        private int _disposeSignaled;
+
+        /// <summary>
+        /// The HwndSource RootVisual (Window) - We store a reference
+        /// to unsubscribe event handlers
+        /// </summary>
+        private Window _sourceWindow;
+
+        /// <summary>
+        /// This flag is set when the browser gets focus before the underlying CEF browser
+        /// has been initialized.
+        /// </summary>
+        private bool _initialFocus;
+        private DirectWritableBitmapRenderHandler _renderHandler;
+        private DirectWritableBitmapRenderHandler _popupRenderHandler;
+        private WindowState _previousWindowState;
+
+        private Rect _popupRect;
+        private bool _showPopup;
+
+        /// <summary>
+        /// Gets a value indicating whether this instance is disposed.
+        /// </summary>
+        /// <value><see langword="true" /> if this instance is disposed; otherwise, <see langword="false" />.</value>
+        public bool IsDisposed => Interlocked.CompareExchange(ref _disposeSignaled, 1, 1) == 1;
+
+        /// <inheritdoc/>
+        public event EventHandler DOMContentLoaded;
+
+        /// <inheritdoc/>
+        public event EventHandler<ErrorEventArgs> BrowserProcessCrashed;
+
+        /// <inheritdoc/>
+        public event EventHandler<FrameEventArgs> FrameAttached;
+
+        /// <inheritdoc/>
+        public event EventHandler<FrameEventArgs> FrameDetached;
+
+        /// <inheritdoc/>
+        public event EventHandler<FrameEventArgs> FrameNavigated;
+
+        /// <inheritdoc/>
+        public event EventHandler JavaScriptLoad;
+
+        /// <inheritdoc/>
+        public event EventHandler<PageErrorEventArgs> RuntimeExceptionThrown;
+
+        /// <inheritdoc/>
+        public event EventHandler<PopupEventArgs> Popup;
+
+        /// <inheritdoc/>
+        public event EventHandler<RequestEventArgs> NetworkRequest;
+
+        /// <inheritdoc/>
+        public event EventHandler<RequestEventArgs> NetworkRequestFailed;
+
+        /// <inheritdoc/>
+        public event EventHandler<RequestEventArgs> NetworkRequestFinished;
+
+        /// <inheritdoc/>
+        public event EventHandler<RequestEventArgs> NetworkRequestServedFromCache;
+
+        /// <inheritdoc/>
+        public event EventHandler<ResponseCreatedEventArgs> NetworkResponse;
+
+        /// <inheritdoc/>
+        public event EventHandler<AddressChangedEventArgs> AddressChanged;
+
+        /// <inheritdoc/>
+        public event EventHandler<LoadingStateChangedEventArgs> LoadingStateChanged;
+
+        /// <inheritdoc/>
+        public event EventHandler<StatusMessageEventArgs> StatusMessage;
+
+        /// <inheritdoc/>
+        public event EventHandler<ConsoleEventArgs> ConsoleMessage;
+
+        /// <inheritdoc/>
+        public event EventHandler<LifecycleEventArgs> LifecycleEvent;
+
+        /// <inheritdoc/>
+        public event EventHandler DevToolsContextAvailable;
+
+        /// <summary>
+        /// Event handler that will get called when the browser title changes
+        /// </summary>
+        public event DependencyPropertyChangedEventHandler TitleChanged;
+
+        /// <summary>
+        /// Navigates to the previous page in the browser history. Will automatically be enabled/disabled depending on the
+        /// browser state.
+        /// </summary>
+        /// <value>The back command.</value>
+        public ICommand BackCommand { get; }
+
+        /// <summary>
+        /// Navigates to the next page in the browser history. Will automatically be enabled/disabled depending on the
+        /// browser state.
+        /// </summary>
+        /// <value>The forward command.</value>
+        public ICommand ForwardCommand { get; }
+
+        /// <summary>
+        /// Reloads the content of the current page. Will automatically be enabled/disabled depending on the browser state.
+        /// </summary>
+        /// <value>The reload command.</value>
+        public ICommand ReloadCommand { get; }
+
+        /// <summary>
+        /// Command which cleans up the Resources used by the ChromiumWebBrowser
+        /// </summary>
+        /// <value>The cleanup command.</value>
+        public ICommand CleanupCommand { get; }
+
+        private static readonly DependencyPropertyKey sTitlePropertyKey;
+        public static readonly DependencyProperty TitleProperty;
+
+
+        static OffscreenChromiumWebBrowser()
+        {
+            sTitlePropertyKey = DependencyProperty.RegisterReadOnly(
+                nameof(Title),
+                typeof(string),
+                typeof(OffscreenChromiumWebBrowser),
+                new PropertyMetadata(OnTitleChanged));
+            TitleProperty = sTitlePropertyKey.DependencyProperty;
+        }
+
+        public OffscreenChromiumWebBrowser(OutOfProcessHost host, string initialAddress = null)
+        {
+            _host = host ?? throw new ArgumentNullException(nameof(host));
+            _initialAddress = initialAddress;
+
+            Focusable = true;
+            FocusVisualStyle = null;
+            IsTabStop = true;
+
+            SizeChanged += OnSizeChanged;
+            IsVisibleChanged += OnIsVisibleChanged;
+
+            BackCommand = new DelegateCommand(() => _devToolsContext.GoBackAsync(), () => CanGoBack);
+            ForwardCommand = new DelegateCommand(() => _devToolsContext.GoForwardAsync(), () => CanGoForward);
+            ReloadCommand = new DelegateCommand(() => _devToolsContext.ReloadAsync(), () => !IsLoading);
+            CleanupCommand = new DelegateCommand(Dispose);
+
+            PresentationSource.AddSourceChangedHandler(this, PresentationSourceChangedHandler);
+
+            UseLayoutRounding = true;
+
+            var hwndHost = new WindowInteropHelper(Application.Current.MainWindow).Handle;
+
+            _host.CreateBrowser(this, hwndHost, url: _initialAddress, out _id);
+            _devToolsContextConnectionTransport = new OutOfProcessConnectionTransport(_id, _host);
+
+            var connection = DevToolsConnection.Attach(_devToolsContextConnectionTransport);
+            _devToolsContext = Dom.DevToolsContext.CreateForOutOfProcess(connection);
+        }
+
+        protected void ShowDevTools() => _host.ShowDevTools(_id);
+
+        /// <inheritdoc/>
+        int IChromiumWebBrowserInternal.Id => _id;
+
+        /// <summary>
+        /// DevToolsContext - provides communication with the underlying browser
+        /// </summary>
+        public IDevToolsContext DevToolsContext => _devToolsReady ? _devToolsContext : default;
+
+        /// <inheritdoc/>
+        public bool IsBrowserInitialized => _browserHwnd != IntPtr.Zero;
+
+        public string Title
+        {
+            get => (string)GetValue(TitleProperty);
+            private set => SetValue(sTitlePropertyKey, value);
+        }
+
+
+        /// <inheritdoc/>
+        void IChromiumWebBrowserInternal.OnDevToolsMessage(string jsonMsg)
+        {
+            _devToolsContextConnectionTransport?.InvokeMessageReceived(jsonMsg);
+        }
+
+        /// <inheritdoc/>
+        async void IChromiumWebBrowserInternal.OnDevToolsReady()
+        {
+            var ctx = _devToolsContext;
+            ctx.DOMContentLoaded += DOMContentLoaded;
+            ctx.Error += BrowserProcessCrashed;
+            ctx.FrameAttached += FrameAttached;
+            ctx.FrameDetached += FrameDetached;
+            ctx.FrameNavigated += FrameNavigated;
+            ctx.Load += JavaScriptLoad;
+            ctx.PageError += RuntimeExceptionThrown;
+            ctx.Popup += Popup;
+            ctx.Request += NetworkRequest;
+            ctx.RequestFailed += NetworkRequestFailed;
+            ctx.RequestFinished += NetworkRequestFinished;
+            ctx.RequestServedFromCache += NetworkRequestServedFromCache;
+            ctx.Response += NetworkResponse;
+            ctx.Console += ConsoleMessage;
+            ctx.LifecycleEvent += LifecycleEvent;
+
+            await ((DevToolsContext)_devToolsContext).InvokeGetFrameTreeAsync();
+            _devToolsReady = true;
+
+            OnInitializeDevToolsContext(DevToolsContext);
+            DevToolsContextAvailable?.Invoke(this, EventArgs.Empty);
+        }
+
+        /// <inheritdoc/>
+        public async void LoadUrl(string url)
+        {
+            await _host.LoadUrl(_id, url);
+        }
+
+        /// <inheritdoc/>
+        public Task<Response> LoadUrlAsync(string url, int? timeout = null, WaitUntilNavigation[] waitUntil = null) 
+            => _devToolsContext.GoToAsync(url, timeout, waitUntil);
+
+        /// <inheritdoc/>
+        public Task<Response> GoBackAsync(NavigationOptions options = null) 
+            => _devToolsContext.GoBackAsync(options);
+
+        /// <inheritdoc/>
+        public Task<Response> GoForwardAsync(NavigationOptions options = null) 
+            => _devToolsContext.GoForwardAsync(options);
+
+        protected virtual void OnInitializeDevToolsContext(IDevToolsContext context)
+        {
+        }
+
+        private void PresentationSourceChangedHandler(object sender, SourceChangedEventArgs args)
+        {
+            if (args.NewSource != null)
+            {
+                var source = (HwndSource)args.NewSource;
+
+                var matrix = source.CompositionTarget.TransformToDevice;
+
+                if (source.RootVisual is Window window)
+                {
+                    window.StateChanged += OnWindowStateChanged;
+                    window.LocationChanged += OnWindowLocationChanged;
+                    _sourceWindow = window;
+
+                    if (CleanupElement == null)
+                    {
+                        CleanupElement = window;
+                    }
+                    else if (CleanupElement is Window parent)
+                    {
+                        //If the CleanupElement is a window then move it to the new Window
+                        if (parent != window)
+                        {
+                            CleanupElement = window;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                if (args.OldSource?.RootVisual is Window window)
+                {
+                    window.StateChanged -= OnWindowStateChanged;
+                    window.LocationChanged -= OnWindowLocationChanged;
+                    _sourceWindow = null;
+                }
+            }
+        }
+
+        ///<inheritdoc/>
+        protected override void OnDpiChanged(DpiScale oldDpi, DpiScale newDpi)
+        {
+            //If the DPI changed then we need to resize.
+            ResizeBrowser((int)ActualWidth, (int)ActualHeight);
+
+            base.OnDpiChanged(oldDpi, newDpi);
+        }
+
+        private void OnSizeChanged(object sender, SizeChangedEventArgs e)
+        {
+            ResizeBrowser((int)e.NewSize.Width, (int)e.NewSize.Height);
+        }
+
+        ///<inheritdoc/>
+        protected override void OnGotKeyboardFocus(KeyboardFocusChangedEventArgs e)
+        {
+            ////Debug.WriteLine($"OnGotKeyboardFocus from {e.OldFocus} to {e.NewFocus}. IsHandled: {e.Handled} Souce: {e.Source} OriginalSouce: {e.OriginalSource}");
+            if (!e.Handled)
+            {
+                if (InternalIsBrowserInitialized())
+                {
+                    _host.SetFocus(_id, true);
+                }
+                else
+                {
+                    _initialFocus = true;
+                }
+            }
+
+            base.OnGotKeyboardFocus(e);
+        }
+
+        ///<inheritdoc/>
+        protected override void OnLostKeyboardFocus(KeyboardFocusChangedEventArgs e)
+        {
+            ////Debug.WriteLine($"OnLostKeyboardFocus from {e.OldFocus} to {e.NewFocus}. IsHandled: {e.Handled} Souce: {e.Source} OriginalSouce: {e.OriginalSource}");
+
+            if (!e.Handled)
+            {
+                if (InternalIsBrowserInitialized())
+                {
+                    _host.SetFocus(_id, false);
+                }
+                else
+                {
+                    _initialFocus = false;
+                }
+            }
+
+            base.OnLostKeyboardFocus(e);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources for the <see cref="OffscreenChromiumWebBrowser"/>
+        /// </summary>
+        /// <param name="disposing"><see langword="true" /> to release both managed and unmanaged resources; <see langword="false" /> to release only unmanaged resources.</param>
+        /// <remarks>
+        /// This method cannot be inlined as the designer will attempt to load libcef.dll and will subsiquently throw an exception.
+        /// </remarks>
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private void InternalDispose(bool disposing)
+        {
+            Interlocked.Exchange(ref _browserInitialized, 0);
+            Interlocked.Exchange(ref _disposeSignaled, 1);
+
+            if (disposing)
+            {
+                _renderHandler?.Dispose();
+                _popupRenderHandler?.Dispose();
+
+                _host.CloseBrowser(_id);
+
+                SizeChanged -= OnSizeChanged;
+                IsVisibleChanged -= OnIsVisibleChanged;
+
+                PresentationSource.RemoveSourceChangedHandler(this, PresentationSourceChangedHandler);
+                // Release window event listeners if PresentationSourceChangedHandler event wasn't
+                // fired before Dispose
+                if (_sourceWindow != null)
+                {
+                    _sourceWindow.StateChanged -= OnWindowStateChanged;
+                    _sourceWindow.LocationChanged -= OnWindowLocationChanged;
+                    _sourceWindow = null;
+                }
+
+                UiThreadRunAsync(() =>
+                {
+                    OnIsBrowserInitializedChanged(true, false);
+
+                    //To Minic the WPF behaviour this happens after OnIsBrowserInitializedChanged
+                    IsBrowserInitializedChanged?.Invoke(this, EventArgs.Empty);
+                });
+
+                IsBrowserInitializedChanged = null;
+                LoadingStateChanged = null;
+                StatusMessage = null;
+
+                if (CleanupElement != null)
+                {
+                    CleanupElement.Unloaded -= OnCleanupElementUnloaded;
+                }
+            }
+        }
+
+        /// <inheritdoc/>
+        void IChromiumWebBrowserInternal.SetAddress(string address)
+        {
+            UiThreadRunAsync(() =>
+            {
+                _ignoreUriChange = true;
+                SetCurrentValue(AddressProperty, address);
+                _ignoreUriChange = false;
+            });
+        }
+
+        /// <inheritdoc/>
+        void IChromiumWebBrowserInternal.SetLoadingStateChange(bool canGoBack, bool canGoForward, bool isLoading)
+        {
+            UiThreadRunAsync(() =>
+            {
+                SetCurrentValue(IsLoadingProperty, isLoading);
+            });
+
+            LoadingStateChanged?.Invoke(this, new LoadingStateChangedEventArgs(canGoBack, canGoForward, isLoading));
+        }
+
+        /// <inheritdoc/>
+        void IChromiumWebBrowserInternal.OnAfterBrowserCreated(IntPtr hwnd)
+        {
+            if (IsDisposed)
+            {
+                return;
+            }
+
+            _browserHwnd = hwnd;
+
+            Interlocked.Exchange(ref _browserInitialized, 1);
+
+            UiThreadRunAsync(() =>
+            {
+                if (!IsDisposed)
+                {
+                    ResizeBrowser((int)ActualWidth, (int)ActualHeight);
+
+                    OnIsBrowserInitializedChanged(false, true);
+
+                    //To Minic the WPF behaviour this happens after OnIsBrowserInitializedChanged
+                    IsBrowserInitializedChanged?.Invoke(this, EventArgs.Empty);
+
+                    // Only call Load if initialAddress is null and Address is not empty
+                    if (string.IsNullOrEmpty(_initialAddress) && !string.IsNullOrEmpty(Address))
+                    {
+                        LoadUrl(Address);
+                    }
+                }
+            });
+
+            if (_initialFocus)
+            {
+                _host.SetFocus(_id, true);
+            }
+        }
+
+        /// <summary>
+        /// A flag that indicates whether the state of the control current supports the GoBack action (true) or not (false).
+        /// </summary>
+        /// <value><c>true</c> if this instance can go back; otherwise, <c>false</c>.</value>
+        /// <remarks>In the WPF control, this property is implemented as a Dependency Property and fully supports data
+        /// binding.</remarks>
+        public bool CanGoBack => (bool)GetValue(CanGoBackProperty);
+
+        /// <summary>
+        /// The can go back property
+        /// </summary>
+        public static readonly DependencyProperty CanGoBackProperty = DependencyProperty.Register(nameof(CanGoBack), typeof(bool), typeof(OffscreenChromiumWebBrowser));
+
+        /// <summary>
+        /// A flag that indicates whether the state of the control currently supports the GoForward action (true) or not (false).
+        /// </summary>
+        /// <value><c>true</c> if this instance can go forward; otherwise, <c>false</c>.</value>
+        /// <remarks>In the WPF control, this property is implemented as a Dependency Property and fully supports data
+        /// binding.</remarks>
+        public bool CanGoForward => (bool)GetValue(CanGoForwardProperty);
+
+        /// <summary>
+        /// The can go forward property
+        /// </summary>
+        public static readonly DependencyProperty CanGoForwardProperty = DependencyProperty.Register(nameof(CanGoForward), typeof(bool), typeof(OffscreenChromiumWebBrowser));
+
+        /// <summary>
+        /// The address (URL) which the browser control is currently displaying.
+        /// Will automatically be updated as the user navigates to another page (e.g. by clicking on a link).
+        /// </summary>
+        /// <value>The address.</value>
+        /// <remarks>In the WPF control, this property is implemented as a Dependency Property and fully supports data
+        /// binding.</remarks>
+        public string Address
+        {
+            get => (string)GetValue(AddressProperty);
+            set => SetValue(AddressProperty, value);
+        }
+
+        /// <summary>
+        /// The address property
+        /// </summary>
+        public static readonly DependencyProperty AddressProperty =
+            DependencyProperty.Register(nameof(Address), typeof(string), typeof(OffscreenChromiumWebBrowser),
+                                        new UIPropertyMetadata(null, OnAddressChanged));
+
+        /// <summary>
+        /// Handles the <see cref="E:AddressChanged" /> event.
+        /// </summary>
+        /// <param name="sender">The sender.</param>
+        /// <param name="args">The <see cref="DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
+        private static void OnAddressChanged(DependencyObject sender, DependencyPropertyChangedEventArgs args)
+        {
+            var owner = (OffscreenChromiumWebBrowser)sender;
+            var oldValue = (string)args.OldValue;
+            var newValue = (string)args.NewValue;
+
+            owner.OnAddressChanged(oldValue, newValue);
+        }
+
+        /// <summary>
+        /// Called when [address changed].
+        /// </summary>
+        /// <param name="oldValue">The old value.</param>
+        /// <param name="newValue">The new value.</param>
+        protected virtual void OnAddressChanged(string oldValue, string newValue)
+        {
+            if (_ignoreUriChange || newValue == null || !InternalIsBrowserInitialized())
+            {
+                return;
+            }
+
+            LoadUrl(newValue);
+        }
+
+        /// <summary>
+        /// A flag that indicates whether the control is currently loading one or more web pages (true) or not (false).
+        /// </summary>
+        /// <value><c>true</c> if this instance is loading; otherwise, <c>false</c>.</value>
+        /// <remarks>In the WPF control, this property is implemented as a Dependency Property and fully supports data
+        /// binding.</remarks>
+        public bool IsLoading => (bool)GetValue(IsLoadingProperty);
+
+        /// <summary>
+        /// The is loading property
+        /// </summary>
+        public static readonly DependencyProperty IsLoadingProperty =
+            DependencyProperty.Register(nameof(IsLoading), typeof(bool), typeof(OffscreenChromiumWebBrowser), new PropertyMetadata(false));
+
+        /// <summary>
+        /// Event called after the underlying CEF browser instance has been created and
+        /// when the <see cref="OffscreenChromiumWebBrowser"/> instance has been Disposed.
+        /// <see cref="IsBrowserInitialized"/> will be true when the underlying CEF Browser
+        /// has been created and false when the browser is being Disposed.
+        /// </summary>
+        public event EventHandler IsBrowserInitializedChanged;
+
+        /// <summary>
+        /// Called when [is browser initialized changed].
+        /// </summary>
+        /// <param name="oldValue">if set to <c>true</c> [old value].</param>
+        /// <param name="newValue">if set to <c>true</c> [new value].</param>
+        protected virtual void OnIsBrowserInitializedChanged(bool oldValue, bool newValue)
+        {
+            if (newValue && !IsDisposed)
+            {
+            }
+        }
+
+        /// <summary>
+        /// The CleanupElement controls when the Browser will be Disposed.
+        /// The <see cref="OffscreenChromiumWebBrowser"/> will be Disposed when <see cref="FrameworkElement.Unloaded"/> is called.
+        /// Be aware that this Control is not usable anymore after it has been disposed.
+        /// </summary>
+        /// <value>The cleanup element.</value>
+        public FrameworkElement CleanupElement
+        {
+            get => (FrameworkElement)GetValue(CleanupElementProperty);
+            set => SetValue(CleanupElementProperty, value);
+        }
+
+        Dom.Frame[] IChromiumWebBrowser.Frames => throw new NotImplementedException();
+
+        Dom.Frame IChromiumWebBrowser.MainFrame => throw new NotImplementedException();
+
+        /// <summary>
+        /// The cleanup element property
+        /// </summary>
+        public static readonly DependencyProperty CleanupElementProperty =
+            DependencyProperty.Register(nameof(CleanupElement), typeof(FrameworkElement), typeof(OffscreenChromiumWebBrowser), new PropertyMetadata(null, OnCleanupElementChanged));
+
+        /// <summary>
+        /// Handles the <see cref="E:CleanupElementChanged" /> event.
+        /// </summary>
+        /// <param name="sender">The sender.</param>
+        /// <param name="args">The <see cref="DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
+        private static void OnCleanupElementChanged(DependencyObject sender, DependencyPropertyChangedEventArgs args)
+        {
+            var owner = (OffscreenChromiumWebBrowser)sender;
+            var oldValue = (FrameworkElement)args.OldValue;
+            var newValue = (FrameworkElement)args.NewValue;
+
+            owner.OnCleanupElementChanged(oldValue, newValue);
+        }
+
+        /// <summary>
+        /// Called when [cleanup element changed].
+        /// </summary>
+        /// <param name="oldValue">The old value.</param>
+        /// <param name="newValue">The new value.</param>
+        protected virtual void OnCleanupElementChanged(FrameworkElement oldValue, FrameworkElement newValue)
+        {
+            if (oldValue != null)
+            {
+                oldValue.Unloaded -= OnCleanupElementUnloaded;
+            }
+
+            if (newValue != null)
+            {
+                newValue.Unloaded += OnCleanupElementUnloaded;
+            }
+        }
+
+        /// <summary>
+        /// Handles the <see cref="E:CleanupElementUnloaded" /> event.
+        /// </summary>
+        /// <param name="sender">The sender.</param>
+        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
+        private void OnCleanupElementUnloaded(object sender, RoutedEventArgs e)
+        {
+            Dispose();
+        }
+
+        /// <summary>
+        /// Runs the specific Action on the Dispatcher in an async fashion
+        /// </summary>
+        /// <param name="action">The action.</param>
+        /// <param name="priority">The priority.</param>
+        private async Task UiThreadRunAsync(Action action, DispatcherPriority priority = DispatcherPriority.DataBind)
+        {
+            if (Dispatcher.CheckAccess())
+            {
+                action();
+            }
+            else if (!Dispatcher.HasShutdownStarted)
+            {
+                await Dispatcher.InvokeAsync(action, priority);
+            }
+        }
+
+        /// <summary>
+        /// Handles the <see cref="E:IsVisibleChanged" /> event.
+        /// </summary>
+        /// <param name="sender">The sender.</param>
+        /// <param name="args">The <see cref="DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
+        private void OnIsVisibleChanged(object sender, DependencyPropertyChangedEventArgs args)
+        {
+            var isVisible = (bool)args.NewValue;
+
+            if (InternalIsBrowserInitialized())
+            {
+                if (isVisible)
+                {
+                    ResizeBrowser((int)ActualWidth, (int)ActualHeight);
+                }
+                else
+                {
+                    NotifyHideBrowser();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Check is <see cref="_browserInitialized"/>
+        /// </summary>
+        /// <returns>true if browser is initialized</returns>
+        private bool InternalIsBrowserInitialized()
+        {
+            // Use CompareExchange to read the current value - if disposeCount is 1, we set it to 1, effectively a no-op
+            // Volatile.Read would likely use a memory barrier which I believe is unnecessary in this scenario
+            return Interlocked.CompareExchange(ref _browserInitialized, 0, 0) == 1;
+        }
+
+        /// <summary>
+        /// Resizes the browser to the specified <paramref name="width"/> and <paramref name="height"/>.
+        /// If <paramref name="width"/> and <paramref name="height"/> are both 0 then the browser
+        /// will be hidden and resource usage will be minimised.
+        /// </summary>
+        /// <param name="width">width</param>
+        /// <param name="height">height</param>
+        protected virtual void ResizeBrowser(int width, int height)
+        {
+            NotifyResizeMoveBrowser(width, height);
+        }
+
+        private void OnWindowStateChanged(object sender, EventArgs e)
+        {
+            var window = (Window)sender;
+
+            switch (window.WindowState)
+            {
+                case WindowState.Normal:
+                case WindowState.Maximized:
+                    {
+                        if (_previousWindowState == WindowState.Minimized)
+                        {
+                            NotifyResizeMoveBrowser();
+                        }
+                        break;
+                    }
+                case WindowState.Minimized:
+                    {
+                        NotifyHideBrowser();
+                        break;
+                    }
+            }
+
+            _previousWindowState = window.WindowState;
+        }
+
+        /// <summary>
+        /// Invoked when an unhandled <see cref="E:System.Windows.Input.Mouse.MouseWheel" /> attached event reaches an element in its route that is derived from this class. Implement this method to add class handling for this event.
+        /// </summary>
+        /// <param name="e">The <see cref="T:System.Windows.Input.MouseWheelEventArgs" /> that contains the event data.</param>
+        protected override async void OnMouseWheel(MouseWheelEventArgs e)
+        {
+            if (DevToolsContext == null)
+            {
+                return;
+            }
+
+            if (!e.Handled)
+            {
+                var isShiftKeyDown = Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift);
+                await DevToolsContext.Mouse.WheelAsync(isShiftKeyDown ? -e.Delta : 0, !isShiftKeyDown ? -e.Delta : 0);
+
+                e.Handled = true;
+            }
+
+            base.OnMouseWheel(e);
+        }
+
+        protected void NotifyHideBrowser()
+        {
+            //// When minimized set the browser window size to 0x0 to reduce resource usage.
+            //// https://github.com/chromiumembedded/cef/blob/c7701b8a6168f105f2c2d6b239ce3958da3e3f13/tests/cefclient/browser/browser_window_std_win.cc#L87
+            if (InternalIsBrowserInitialized())
+            {
+                _host.NotifyMoveOrResizeStarted(_id, default);
+            }
+        }
+
+        private void NotifyResizeMoveBrowser(int width, int height)
+        {
+            if (InternalIsBrowserInitialized())
+            {
+                var point = IsArrangeValid && width > 0 ? PointToScreen(default) : default;
+                _host.NotifyMoveOrResizeStarted(_id, new Interface.Rect((int)point.X, (int)point.Y, width, height));
+            }
+        }
+
+        protected void NotifyResizeMoveBrowser() => NotifyResizeMoveBrowser((int)ActualWidth, (int)ActualHeight);
+
+        private void OnWindowLocationChanged(object sender, EventArgs e) => NotifyResizeMoveBrowser();
+
+        /// <summary>
+        /// Throw exception if browser not initialized.
+        /// </summary>
+        /// <exception cref="Exception">Thrown when an exception error condition occurs.</exception>
+        private void ThrowExceptionIfBrowserNotInitialized()
+        {
+            if (!InternalIsBrowserInitialized())
+            {
+                throw new Exception(BrowserNotInitializedExceptionErrorMessage);
+            }
+        }
+
+        /// <summary>
+        /// Throw exception if disposed.
+        /// </summary>
+        /// <exception cref="ObjectDisposedException">Thrown when a supplied object has been disposed.</exception>
+        private void ThrowExceptionIfDisposed()
+        {
+            if (IsDisposed)
+            {
+                throw new ObjectDisposedException("browser", "Browser has been disposed");
+            }
+        }
+
+        private void Dispose() => Dispose(true);
+
+        void IDisposable.Dispose() => Dispose(true);
+
+        protected virtual void Dispose(bool isDisposing)
+        {
+            InternalDispose(isDisposing);
+        }
+
+        void IRenderHandlerInternal.OnPaint(bool isPopup, Interface.Rect directRect, int width, int height, string file)
+        {
+            const int defaultDpi = 96;
+            const double scale = defaultDpi * 1.0;
+            if (_renderHandler == null && !IsDisposed)
+            {
+                _renderHandler = new DirectWritableBitmapRenderHandler(scale, scale);
+                _popupRenderHandler = new DirectWritableBitmapRenderHandler(scale, scale);
+            }
+
+            UiThreadRunAsync(() =>
+            {
+                if (isPopup)
+                {
+                    _popupRenderHandler?.OnPaint(directRect, width, height, _popupImage, file);
+                }
+                else
+                {
+                    _renderHandler?.OnPaint(directRect, width, height, _image, file);
+                }
+
+                InvalidateVisual();
+            }, DispatcherPriority.Render);
+        }
+
+        void IRenderHandlerInternal.OnPopupShow(bool show)
+        {
+            _showPopup = show;
+        }
+
+        void IRenderHandlerInternal.OnPopupSize(Interface.Rect rect)
+        {
+            _popupRect = new Rect(rect.X, rect.Y, rect.Width, rect.Height);
+        }
+
+        protected override void OnRender(DrawingContext drawingContext)
+        {
+            base.OnRender(drawingContext);
+            if (_image?.Source != null)
+            {
+                drawingContext.DrawImage(_image.Source, new Rect(0, 0, (int)_image.Source.Width, (int)_image.Source.Height));
+            }
+
+            if (_showPopup && _popupImage != null && _image?.Source != null)
+            {
+                drawingContext.DrawImage(_popupImage.Source, _popupRect);
+            }
+        }
+
+        #region wpf browser impl
+
+        /// <summary>
+        /// Invoked when an unhandled <see cref="E:System.Windows.Input.Mouse.MouseMove" /> attached event reaches an element in its route that is derived from this class. Implement this method to add class handling for this event.
+        /// </summary>
+        /// <param name="e">The <see cref="T:System.Windows.Input.MouseEventArgs" /> that contains the event data.</param>
+        protected override async void OnMouseMove(MouseEventArgs e)
+        {
+            if (DevToolsContext == null)
+            {
+                return;
+            }
+
+            //Mouse, touch, and stylus will raise mouse event.
+            //For mouse events from an actual mouse, e.StylusDevice will be null.
+            //For mouse events from touch and stylus, e.StylusDevice will not be null.
+            //We only handle event from mouse here.
+            //If not, touch will cause duplicate events (mousemove and touchmove) and so does stylus.
+            //Use e.StylusDevice == null to ensure only mouse.
+            if (!e.Handled && _host != null && e.StylusDevice == null)
+            {
+                var point = e.GetPosition(this);
+
+                await DevToolsContext.Mouse
+                  .MoveAsync((decimal)point.X, (decimal)point.Y);
+            }
+
+            base.OnMouseMove(e);
+        }
+
+        /// <summary>
+        /// Invoked when an unhandled <see cref="E:System.Windows.Input.Mouse.MouseDown" /> attached event reaches an
+        /// element in its route that is derived from this class. Implement this method to add class handling for this event.
+        /// </summary>
+        /// <param name="e">The <see cref="T:System.Windows.Input.MouseButtonEventArgs" /> that contains the event data.
+        /// This event data reports details about the mouse button that was pressed and the handled state.</param>
+        protected override void OnMouseDown(MouseButtonEventArgs e)
+        {
+            if (DevToolsContext == null)
+            {
+                return;
+            }
+
+            //Mouse, touch, and stylus will raise mouse event.
+            //For mouse events from an actual mouse, e.StylusDevice will be null.
+            //For mouse events from touch and stylus, e.StylusDevice will not be null.
+            //We only handle event from mouse here.
+            //If not, touch will cause duplicate events (mouseup and touchup) and so does stylus.
+            //Use e.StylusDevice == null to ensure only mouse.
+            if (e.StylusDevice == null)
+            {
+                Focus();
+
+                OnMouseButton(e);
+
+                //We should only need to capture the left button exiting the browser
+                if (e.ChangedButton == MouseButton.Left && e.LeftButton == MouseButtonState.Pressed)
+                {
+                    //Capture/Release Mouse to allow for scrolling outside bounds of browser control (#2258).
+                    //Known issue when capturing and the device has a touch screen, to workaround this issue
+                    //disable WPF StylusAndTouchSupport see for details https://github.com/dotnet/wpf/issues/1323#issuecomment-513870984
+                    CaptureMouse();
+                }
+            }
+
+            base.OnMouseDown(e);
+        }
+
+
+        /// <summary>
+        /// Invoked when an unhandled <see cref="E:System.Windows.Input.Mouse.MouseUp" /> routed event reaches an element in its route that is derived from this class. Implement this method to add class handling for this event.
+        /// </summary>
+        /// <param name="e">The <see cref="T:System.Windows.Input.MouseButtonEventArgs" /> that contains the event data. The event data reports that the mouse button was released.</param>
+        protected override void OnMouseUp(MouseButtonEventArgs e)
+        {
+            if (DevToolsContext == null)
+            {
+                return;
+            }
+
+            //Mouse, touch, and stylus will raise mouse event.
+            //For mouse events from an actual mouse, e.StylusDevice will be null.
+            //For mouse events from touch and stylus, e.StylusDevice will not be null.
+            //We only handle event from mouse here.
+            //If not, touch will cause duplicate events (mouseup and touchup) and so does stylus.
+            //Use e.StylusDevice == null to ensure only mouse.
+            if (e.StylusDevice == null)
+            {
+                OnMouseButton(e);
+
+                if (e.ChangedButton == MouseButton.Left && e.LeftButton == MouseButtonState.Released)
+                {
+                    //Release the mouse capture that we grabbed on mouse down.
+                    //We won't get here if e.g. the right mouse button is pressed and released
+                    //while the left is still held, but in that case the left mouse capture seems
+                    //to be released implicitly (even without the left mouse SendMouseClickEvent in leave below)
+                    //Use ReleaseMouseCapture over Mouse.Capture(null); as it has additional Mouse.Captured == this check
+                    ReleaseMouseCapture();
+                }
+            }
+
+            base.OnMouseUp(e);
+        }
+
+        /// <summary>
+        /// Invoked when an unhandled <see cref="E:System.Windows.Input.Mouse.MouseLeave" /> attached event is raised on this element. Implement this method to add class handling for this event.
+        /// </summary>
+        /// <param name="e">The <see cref="T:System.Windows.Input.MouseEventArgs" /> that contains the event data.</param>
+        protected override async void OnMouseLeave(MouseEventArgs e)
+        {
+            if (DevToolsContext == null)
+            {
+                return;
+            }
+
+            //Mouse, touch, and stylus will raise mouse event.
+            //For mouse events from an actual mouse, e.StylusDevice will be null.
+            //For mouse events from touch and stylus, e.StylusDevice will not be null.
+            //We only handle event from mouse here.
+            //OnMouseLeave event from touch or stylus needn't to be handled.
+            //Use e.StylusDevice == null to ensure only mouse.
+            if (!e.Handled && _host != null && e.StylusDevice == null)
+            {
+                var point = e.GetPosition(this);
+
+                await DevToolsContext.Mouse
+                .MoveAsync((decimal)point.X, (decimal)point.Y);
+            }
+
+            base.OnMouseLeave(e);
+        }
+
+        void IChromiumWebBrowserInternal.SetStatusMessage(string msg)
+        {
+            StatusMessage?.Invoke(this, new StatusMessageEventArgs(msg));
+        }
+
+        void IChromiumWebBrowserInternal.SetTitle(string title) => UiThreadRunAsync(() => { Title = title; });
+
+        /// <summary>
+        /// Handles the <see cref="E:TitleChanged" /> event.
+        /// </summary>
+        /// <param name="d">The d.</param>
+        /// <param name="e">The <see cref="DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
+        private static void OnTitleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) => ((OffscreenChromiumWebBrowser)d).TitleChanged?.Invoke(d, e);
+
+        /// <summary>
+        /// Invoked when an unhandled <see cref="E:System.Windows.Input.Keyboard.PreviewKeyDown" /> attached event reaches an
+        /// element in its route that is derived from this class. Implement this method to add class handling for this event.
+        /// </summary>
+        /// <param name="e">The <see cref="T:System.Windows.Input.KeyEventArgs" /> that contains the event data.</param>
+        protected override void OnPreviewKeyDown(KeyEventArgs e)
+        {
+            if (!e.Handled && DevToolsContext != null)
+            {
+                HandleKeyPress(e);
+            }
+
+            base.OnPreviewKeyDown(e);
+        }
+
+        /// <summary>
+        /// Invoked when an unhandled <see cref="E:System.Windows.Input.Keyboard.PreviewKeyUp" /> attached event reaches an
+        /// element in its route that is derived from this class. Implement this method to add class handling for this event.
+        /// </summary>
+        /// <param name="e">The <see cref="T:System.Windows.Input.KeyEventArgs" /> that contains the event data.</param>
+        protected override void OnPreviewKeyUp(KeyEventArgs e)
+        {
+            if (!e.Handled && DevToolsContext != null)
+            {
+                HandleKeyPress(e);
+            }
+
+            base.OnPreviewKeyUp(e);
+        }
+
+        /// <summary>
+        /// Handles the <see cref="E:PreviewTextInput" /> event.
+        /// </summary>
+        /// <param name="e">The <see cref="TextCompositionEventArgs"/> instance containing the event data.</param>
+        protected override void OnPreviewTextInput(TextCompositionEventArgs e)
+        {
+            if (!e.Handled)
+            {
+                HandleTextInput(e);
+            }
+
+            base.OnPreviewTextInput(e);
+        }
+
+        private void HandleKeyPress(KeyEventArgs e)
+        {
+            var key = e.SystemKey == Key.None ? e.Key : e.SystemKey;
+            if (DevToolsContext == null)
+            {
+                return;
+            }
+
+            // Hooking the Tab key like this makes the tab focusing in essence work like
+            // KeyboardNavigation.TabNavigation="Cycle"; you will never be able to Tab out of the web browser control.
+            // We also add the condition to allow ctrl+a to work when the web browser control is put inside listbox.
+            // Prevent keyboard navigation using arrows and home and end keys
+            if (key == Key.Tab || key == Key.Home || key == Key.End || key == Key.Up
+                               || key == Key.Down || key == Key.Left || key == Key.Right || key == Key.Escape
+                               || (key == Key.A && Keyboard.Modifiers == ModifierKeys.Control))
+            {
+                e.Handled = true;
+            }
+
+            if (!_keyMapping.ContainsKey(e.Key.ToString()))
+            {
+                return;
+            }
+
+            if (e.IsDown)
+            {
+                DevToolsContext.Keyboard.DownAsync(_keyMapping[e.Key.ToString()]);
+            }
+            else
+            {
+                DevToolsContext.Keyboard.UpAsync(_keyMapping[e.Key.ToString()]);
+            }
+        }
+
+        private async void HandleTextInput(TextCompositionEventArgs e)
+        {
+            if (DevToolsContext == null)
+            {
+                return;
+            }
+
+            if (e.Text == "\b")
+            {
+                await DevToolsContext.Keyboard.PressAsync("Backspace");
+            }
+            else
+            {
+                await DevToolsContext.Keyboard.TypeAsync(e.Text);
+            }
+
+            e.Handled = true;
+        }
+
+
+        /// <summary>
+        /// Handles the <see cref="E:MouseButton" /> event.
+        /// </summary>
+        /// <param name="e">The <see cref="MouseButtonEventArgs"/> instance containing the event data.</param>
+        private void OnMouseButton(MouseButtonEventArgs e)
+        {
+            if (e.Handled || !_devToolsReady)
+            {
+                return;
+            }
+
+            var mouseUp = e.ButtonState == MouseButtonState.Released;
+            var point = e.GetPosition(this);
+
+            //// Chromium only supports values of 1, 2 or 3.
+            //// https://github.com/cefsharp/CefSharp/issues/3940
+            //// Anything greater than 3 then we send click count of 1
+            var clickCount = e.ClickCount;
+            if (clickCount > 3)
+            {
+                clickCount = 1;
+            }
+
+            _host.SendMouseClickEvent(_id, (int)point.X, (int)point.Y, (MouseButtonType)e.ChangedButton, mouseUp, clickCount, e.GetModifiers());
+
+            e.Handled = true;
+        }
+
+        #endregion
+    }
+}
diff --git a/CefSharp.OutOfProcess.sln b/CefSharp.OutOfProcess.sln
index 630e80f..7fd4edf 100644
--- a/CefSharp.OutOfProcess.sln
+++ b/CefSharp.OutOfProcess.sln
@@ -1,67 +1,79 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.32510.428
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.WinForms.Example", "CefSharp.OutOfProcess.WinForms.Example\CefSharp.OutOfProcess.WinForms.Example.csproj", "{A1C85784-7C6F-4C83-9AC4-B3413F32FF31}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.BrowserProcess", "CefSharp.OutOfProcess.BrowserProcess\CefSharp.OutOfProcess.BrowserProcess.csproj", "{8CB2936D-E12C-4CD2-9044-F264D6F0547B}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.WinForms", "CefSharp.OutOfProcess.WinForms\CefSharp.OutOfProcess.WinForms.csproj", "{8287C019-2720-47D5-8077-1A2DADB510E6}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.Core", "CefSharp.OutOfProcess.Core\CefSharp.OutOfProcess.Core.csproj", "{6ED4E6BF-F43A-429C-87FD-E66203EEC348}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.Interface", "CefSharp.OutOfProcess.Interface\CefSharp.OutOfProcess.Interface.csproj", "{D466B2AE-284B-430B-B707-F5D387724965}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.Wpf.HwndHost", "CefSharp.OutOfProcess.Wpf.HwndHost\CefSharp.OutOfProcess.Wpf.HwndHost.csproj", "{85605A77-9882-4595-96A1-089244BCCE24}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.Wpf.HwndHost.Example", "CefSharp.OutOfProcess.Wpf.HwndHost.Example\CefSharp.OutOfProcess.Wpf.HwndHost.Example.csproj", "{329D005F-3E63-4D0B-A86F-15CDD9F9AF2E}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.Dom.OutOfProcess", "CefSharp.Dom\lib\PuppeteerSharp\CefSharp.Dom.OutOfProcess.csproj", "{7D39CC02-FB02-4F03-B329-E5DB567EC354}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{A1C85784-7C6F-4C83-9AC4-B3413F32FF31}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{A1C85784-7C6F-4C83-9AC4-B3413F32FF31}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{A1C85784-7C6F-4C83-9AC4-B3413F32FF31}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{A1C85784-7C6F-4C83-9AC4-B3413F32FF31}.Release|Any CPU.Build.0 = Release|Any CPU
-		{8CB2936D-E12C-4CD2-9044-F264D6F0547B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{8CB2936D-E12C-4CD2-9044-F264D6F0547B}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{8CB2936D-E12C-4CD2-9044-F264D6F0547B}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{8CB2936D-E12C-4CD2-9044-F264D6F0547B}.Release|Any CPU.Build.0 = Release|Any CPU
-		{8287C019-2720-47D5-8077-1A2DADB510E6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{8287C019-2720-47D5-8077-1A2DADB510E6}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{8287C019-2720-47D5-8077-1A2DADB510E6}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{8287C019-2720-47D5-8077-1A2DADB510E6}.Release|Any CPU.Build.0 = Release|Any CPU
-		{6ED4E6BF-F43A-429C-87FD-E66203EEC348}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{6ED4E6BF-F43A-429C-87FD-E66203EEC348}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{6ED4E6BF-F43A-429C-87FD-E66203EEC348}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{6ED4E6BF-F43A-429C-87FD-E66203EEC348}.Release|Any CPU.Build.0 = Release|Any CPU
-		{D466B2AE-284B-430B-B707-F5D387724965}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D466B2AE-284B-430B-B707-F5D387724965}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{D466B2AE-284B-430B-B707-F5D387724965}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D466B2AE-284B-430B-B707-F5D387724965}.Release|Any CPU.Build.0 = Release|Any CPU
-		{85605A77-9882-4595-96A1-089244BCCE24}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{85605A77-9882-4595-96A1-089244BCCE24}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{85605A77-9882-4595-96A1-089244BCCE24}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{85605A77-9882-4595-96A1-089244BCCE24}.Release|Any CPU.Build.0 = Release|Any CPU
-		{329D005F-3E63-4D0B-A86F-15CDD9F9AF2E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{329D005F-3E63-4D0B-A86F-15CDD9F9AF2E}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{329D005F-3E63-4D0B-A86F-15CDD9F9AF2E}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{329D005F-3E63-4D0B-A86F-15CDD9F9AF2E}.Release|Any CPU.Build.0 = Release|Any CPU
-		{7D39CC02-FB02-4F03-B329-E5DB567EC354}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{7D39CC02-FB02-4F03-B329-E5DB567EC354}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{7D39CC02-FB02-4F03-B329-E5DB567EC354}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{7D39CC02-FB02-4F03-B329-E5DB567EC354}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {5E011DD5-7B05-4678-AFFD-5FDEACB52718}
-	EndGlobalSection
-EndGlobal
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.5.33103.201
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.WinForms.Example", "CefSharp.OutOfProcess.WinForms.Example\CefSharp.OutOfProcess.WinForms.Example.csproj", "{A1C85784-7C6F-4C83-9AC4-B3413F32FF31}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.BrowserProcess", "CefSharp.OutOfProcess.BrowserProcess\CefSharp.OutOfProcess.BrowserProcess.csproj", "{8CB2936D-E12C-4CD2-9044-F264D6F0547B}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.WinForms", "CefSharp.OutOfProcess.WinForms\CefSharp.OutOfProcess.WinForms.csproj", "{8287C019-2720-47D5-8077-1A2DADB510E6}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.Core", "CefSharp.OutOfProcess.Core\CefSharp.OutOfProcess.Core.csproj", "{6ED4E6BF-F43A-429C-87FD-E66203EEC348}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.Interface", "CefSharp.OutOfProcess.Interface\CefSharp.OutOfProcess.Interface.csproj", "{D466B2AE-284B-430B-B707-F5D387724965}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.Wpf.HwndHost", "CefSharp.OutOfProcess.Wpf.HwndHost\CefSharp.OutOfProcess.Wpf.HwndHost.csproj", "{85605A77-9882-4595-96A1-089244BCCE24}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.Wpf.HwndHost.Example", "CefSharp.OutOfProcess.Wpf.HwndHost.Example\CefSharp.OutOfProcess.Wpf.HwndHost.Example.csproj", "{329D005F-3E63-4D0B-A86F-15CDD9F9AF2E}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.Dom.OutOfProcess", "CefSharp.Dom\lib\PuppeteerSharp\CefSharp.Dom.OutOfProcess.csproj", "{7D39CC02-FB02-4F03-B329-E5DB567EC354}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.Wpf.OffscreenHost", "CefSharp.OutOfProcess.Wpf.OffscreenHost\CefSharp.OutOfProcess.Wpf.OffscreenHost.csproj", "{04A51458-0957-4A1D-98DF-8BB5E9887B09}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CefSharp.OutOfProcess.Wpf.OffscreenHost.Example", "CefSharp.OutOfProcess.Wpf.OffscreenHost.Example\CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.csproj", "{E61E72F2-4FFE-4E86-8BDC-F176796D8034}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{A1C85784-7C6F-4C83-9AC4-B3413F32FF31}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A1C85784-7C6F-4C83-9AC4-B3413F32FF31}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A1C85784-7C6F-4C83-9AC4-B3413F32FF31}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A1C85784-7C6F-4C83-9AC4-B3413F32FF31}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8CB2936D-E12C-4CD2-9044-F264D6F0547B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8CB2936D-E12C-4CD2-9044-F264D6F0547B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8CB2936D-E12C-4CD2-9044-F264D6F0547B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8CB2936D-E12C-4CD2-9044-F264D6F0547B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8287C019-2720-47D5-8077-1A2DADB510E6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8287C019-2720-47D5-8077-1A2DADB510E6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8287C019-2720-47D5-8077-1A2DADB510E6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8287C019-2720-47D5-8077-1A2DADB510E6}.Release|Any CPU.Build.0 = Release|Any CPU
+		{6ED4E6BF-F43A-429C-87FD-E66203EEC348}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6ED4E6BF-F43A-429C-87FD-E66203EEC348}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6ED4E6BF-F43A-429C-87FD-E66203EEC348}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6ED4E6BF-F43A-429C-87FD-E66203EEC348}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D466B2AE-284B-430B-B707-F5D387724965}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D466B2AE-284B-430B-B707-F5D387724965}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D466B2AE-284B-430B-B707-F5D387724965}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D466B2AE-284B-430B-B707-F5D387724965}.Release|Any CPU.Build.0 = Release|Any CPU
+		{85605A77-9882-4595-96A1-089244BCCE24}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{85605A77-9882-4595-96A1-089244BCCE24}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{85605A77-9882-4595-96A1-089244BCCE24}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{85605A77-9882-4595-96A1-089244BCCE24}.Release|Any CPU.Build.0 = Release|Any CPU
+		{329D005F-3E63-4D0B-A86F-15CDD9F9AF2E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{329D005F-3E63-4D0B-A86F-15CDD9F9AF2E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{329D005F-3E63-4D0B-A86F-15CDD9F9AF2E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{329D005F-3E63-4D0B-A86F-15CDD9F9AF2E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{7D39CC02-FB02-4F03-B329-E5DB567EC354}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7D39CC02-FB02-4F03-B329-E5DB567EC354}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7D39CC02-FB02-4F03-B329-E5DB567EC354}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7D39CC02-FB02-4F03-B329-E5DB567EC354}.Release|Any CPU.Build.0 = Release|Any CPU
+		{04A51458-0957-4A1D-98DF-8BB5E9887B09}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{04A51458-0957-4A1D-98DF-8BB5E9887B09}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{04A51458-0957-4A1D-98DF-8BB5E9887B09}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{04A51458-0957-4A1D-98DF-8BB5E9887B09}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E61E72F2-4FFE-4E86-8BDC-F176796D8034}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E61E72F2-4FFE-4E86-8BDC-F176796D8034}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E61E72F2-4FFE-4E86-8BDC-F176796D8034}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E61E72F2-4FFE-4E86-8BDC-F176796D8034}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {5E011DD5-7B05-4678-AFFD-5FDEACB52718}
+	EndGlobalSection
+EndGlobal

From 3caf72036d7b74637695f5923b839d11dc5c0063 Mon Sep 17 00:00:00 2001
From: Sebastian Mayer <sebastian.mayer@trumpf.com>
Date: Mon, 30 Jan 2023 17:27:33 +0100
Subject: [PATCH 2/2] remove 2 unused files

---
 .../CefSharp.WPF.Internals/RectStruct.cs      | 48 -------------------
 .../TextBoxBindingUpdateOnEnterBehaviour.cs   | 28 -----------
 .../MainWindow.xaml                           | 11 -----
 3 files changed, 87 deletions(-)
 delete mode 100644 CefSharp.OutOfProcess.BrowserProcess/CefSharp.WPF.Internals/RectStruct.cs
 delete mode 100644 CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Behaviours/TextBoxBindingUpdateOnEnterBehaviour.cs

diff --git a/CefSharp.OutOfProcess.BrowserProcess/CefSharp.WPF.Internals/RectStruct.cs b/CefSharp.OutOfProcess.BrowserProcess/CefSharp.WPF.Internals/RectStruct.cs
deleted file mode 100644
index 7999a6a..0000000
--- a/CefSharp.OutOfProcess.BrowserProcess/CefSharp.WPF.Internals/RectStruct.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright © 2018 The CefSharp Authors. All rights reserved.
-//
-// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
-
-using System.Runtime.InteropServices;
-using CefSharp.Structs;
-
-namespace CefSharp.Wpf.Internals
-{
-    /// <summary>
-    /// The RECT structure defines the coordinates of the upper-left and lower-right corners of a rectangle.
-    /// </summary>
-    /// <see cref="https://docs.microsoft.com/en-us/previous-versions/dd162897(v=vs.85)"/>
-    /// <remarks>
-    /// By convention, the right and bottom edges of the rectangle are normally considered exclusive. 
-    /// In other words, the pixel whose coordinates are ( right, bottom ) lies immediately outside of the the rectangle. 
-    /// For example, when RECT is passed to the FillRect function, the rectangle is filled up to, but not including, 
-    /// the right column and bottom row of pixels. This structure is identical to the RECTL structure.
-    /// </remarks>
-    [StructLayout(LayoutKind.Sequential)]
-    public struct RectStruct
-    {
-        /// <summary>
-        /// The x-coordinate of the upper-left corner of the rectangle.
-        /// </summary>
-        public int Left;
-
-        /// <summary>
-        /// The y-coordinate of the upper-left corner of the rectangle.
-        /// </summary>
-        public int Top;
-
-        /// <summary>
-        /// The x-coordinate of the lower-right corner of the rectangle.
-        /// </summary>
-        public int Right;
-
-        /// <summary>
-        /// The y-coordinate of the lower-right corner of the rectangle.
-        /// </summary>
-        public int Bottom;
-
-        public static implicit operator Rect(RectStruct rect)
-        {
-            return new Rect(0, 0, rect.Right - rect.Left, rect.Bottom - rect.Top);
-        }
-    }
-}
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Behaviours/TextBoxBindingUpdateOnEnterBehaviour.cs b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Behaviours/TextBoxBindingUpdateOnEnterBehaviour.cs
deleted file mode 100644
index 0d9b1f8..0000000
--- a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/Behaviours/TextBoxBindingUpdateOnEnterBehaviour.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-namespace CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.Behaviours
-{
-    using System.Windows.Controls;
-    using System.Windows.Input;
-    using Microsoft.Xaml.Behaviors;
-
-    public class TextBoxBindingUpdateOnEnterBehaviour : Behavior<TextBox>
-    {
-        protected override void OnAttached()
-        {
-            AssociatedObject.KeyDown += OnTextBoxKeyDown;
-        }
-
-        protected override void OnDetaching()
-        {
-            AssociatedObject.KeyDown -= OnTextBoxKeyDown;
-        }
-
-        private void OnTextBoxKeyDown(object sender, KeyEventArgs e)
-        {
-            if (e.Key == Key.Enter)
-            {
-                var txtBox = sender as TextBox;
-                txtBox.GetBindingExpression(TextBox.TextProperty).UpdateSource();
-            }
-        }
-    }
-}
diff --git a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/MainWindow.xaml b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/MainWindow.xaml
index b342b39..0ad884a 100644
--- a/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/MainWindow.xaml
+++ b/CefSharp.OutOfProcess.Wpf.OffscreenHost.Example/MainWindow.xaml
@@ -3,8 +3,6 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-        xmlns:behaviors="http://schemas.microsoft.com/xaml/behaviors"
-        xmlns:offscreenhost="clr-namespace:CefSharp.OutOfProcess.Wpf.OffscreenHost.Example.Behaviours"
         FocusManager.FocusedElement="{Binding ElementName=Browser}"
         mc:Ignorable="d"
         Title="MainWindow" Height="768" Width="1024">
@@ -34,9 +32,6 @@
             <Button Content="Back" Command="{Binding WebBrowser.BackCommand, ElementName=Browser}" Width="50"/>
             <Button Content="Forward" Command="{Binding WebBrowser.ForwardCommand, ElementName=Browser}" Grid.Column="1" Width="60"/>
             <TextBox x:Name="txtBoxAddress" Text="{Binding Address, ElementName=Browser, FallbackValue=www.google.com}" Grid.Column="2" FontSize="12" BorderBrush="Gray" BorderThickness="1">
-                <!--<behaviors:Interaction.Behaviors>
-                    <offscreenhost:HoverLinkBehaviour />
-                </behaviors:Interaction.Behaviors>-->
             </TextBox>
             <Button Content="Print..." Command="{Binding WebBrowser.PrintCommand, ElementName=Browser}" Grid.Column="3" Width="50" />
             <Button Content="View source" Command="{Binding WebBrowser.ViewSourceCommand, ElementName=Browser}" Grid.Column="4" Width="75" />
@@ -44,12 +39,6 @@
         </Grid>
         <Border Grid.Row="1" BorderBrush="Gray" BorderThickness="0,1">
             <ContentPresenter x:Name="BrowserContentPresenter" />
-            <!--<Offscreenhost:ChromiumWebBrowser x:Name="Browser"
-                                    Address="https://www.google.com">
-                <behaviors:Interaction.Behaviors>
-                    <behaviours:HoverLinkBehaviour x:Name="HoverLinkBehaviour"/>
-                </behaviors:Interaction.Behaviors>
-            </Offscreenhost:ChromiumWebBrowser>-->
         </Border>
         <ProgressBar IsIndeterminate="{Binding IsLoading, ElementName=Browser}"
                      HorizontalAlignment="Stretch"