OverlayWebBrowser to use a browser on transparent WPF window

    public class OverlayWebBrowser : Control
    {
        private Overlay _overlay;

        public OverlayWebBrowser()
        {
            this.Loaded += new RoutedEventHandler(OverlayWebBrowser_Loaded);
        }

        void OverlayWebBrowser_Loaded(object sender, RoutedEventArgs e)
        {
            if (_overlay == null)
                _overlay = new Overlay(this);
            _overlay.WebBrowser.Source = this.Source;
        }

        public Uri Source
        {
            get { return (Uri)GetValue(SourceProperty); }
            set { SetValue(SourceProperty, value); }
        }

        // Using a DependencyProperty as the backing store for Source.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty SourceProperty =
            DependencyProperty.Register(
                "Source",
                typeof(Uri),
                typeof(OverlayWebBrowser),
                new UIPropertyMetadata(
                    null,
                    SourceChanged));

        private static void SourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            OverlayWebBrowser wb = d as OverlayWebBrowser;
            if (wb != null && wb._overlay != null)
            {
                wb._overlay.WebBrowser.Source = e.NewValue as Uri;
            }
        }

        /// <summary>
        /// Displays a WebBrowser control over a given placement target element in a WPF Window.
        /// The owner window can be transparent, but not this one, due mixing DirectX and GDI drawing.
        /// WebBrowserOverlayWF uses WinForms to avoid this limitation.
        /// </summary>
        private class Overlay : Window
        {
            FrameworkElement _placementTarget;
            WebBrowser _wb;

            public WebBrowser WebBrowser { get { return _wb; } }

            public Overlay(FrameworkElement placementTarget)
            {
                WindowStyle = WindowStyle.None;
                ShowInTaskbar = false;
                ResizeMode = ResizeMode.NoResize;

                _wb = new WebBrowser();
                Content = _wb;

                _placementTarget = placementTarget;
                Window owner = Window.GetWindow(placementTarget);

                owner.LocationChanged += delegate { OnSizeLocationChanged(); };
                _placementTarget.SizeChanged += delegate { OnSizeLocationChanged(); };

                Action showAction = () =>
                                    {
                                        Owner = owner;
                                        OnSizeLocationChanged();
                                        Show();
                                    };

                if (owner.IsVisible)
                {
                    showAction();
                }
                else
                {
                    DependencyPropertyChangedEventHandler handler = null;
                    handler = delegate
                    {
                        if (owner.IsVisible)
                        {
                            showAction();
                            owner.IsVisibleChanged -= handler;
                        }
                    };
                    owner.IsVisibleChanged += handler;
                }
            }



            protected override void OnClosing(System.ComponentModel.CancelEventArgs e)
            {
                base.OnClosing(e);
                if (!e.Cancel)
                    // Delayed call to avoid crash due to Window bug.
                    Dispatcher.BeginInvoke(new Action(() => Owner.Close()));
            }

            void OnSizeLocationChanged()
            {
                Point offset = _placementTarget.TranslatePoint(new Point(), Owner);
                Point size = new Point(_placementTarget.ActualWidth, _placementTarget.ActualHeight);
                HwndSource hwndSource = (HwndSource)PresentationSource.FromVisual(Owner);
                CompositionTarget ct = hwndSource.CompositionTarget;
                offset = ct.TransformToDevice.Transform(offset);
                size = ct.TransformToDevice.Transform(size);

                POINT screenLocation = new POINT(offset);
                ClientToScreen(hwndSource.Handle, ref screenLocation);
                POINT screenSize = new POINT(size);

                if (IsLoaded)
                {
                    MoveWindow(((HwndSource)PresentationSource.FromVisual(this)).Handle, screenLocation.X, screenLocation.Y, screenSize.X, screenSize.Y, true);
                }
                else
                {
                    this.Left = screenLocation.X;
                    this.Top = screenLocation.Y;
                    this.Width = screenSize.X;
                    this.Height = screenSize.Y;
                }
            }

            [StructLayout(LayoutKind.Sequential)]
            public struct POINT
            {
                public int X;
                public int Y;

                public POINT(int x, int y)
                {
                    this.X = x;
                    this.Y = y;
                }
                public POINT(Point pt)
                {
                    X = Convert.ToInt32(pt.X);
                    Y = Convert.ToInt32(pt.Y);
                }
            };

            [DllImport("user32.dll")]
            internal static extern bool ClientToScreen(IntPtr hWnd, ref POINT lpPoint);

            [DllImport("user32.dll")]
            internal static extern bool MoveWindow(IntPtr hWnd, int X, int Y, int nWidth, int nHeight, bool bRepaint);
        }
    }