DockableWindowHost.cs

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Drawing;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace SlimDucky
{
    [ComVisible(true)]
    [Guid(Guid)]
    [ProgId(ProgId)]
    [EditorBrowsable(EditorBrowsableState.Never)]
    //Nothing breaks because we declare a ProgId
    // ReSharper disable once InconsistentNaming
    //Underscores make classes invisible to VB6 object explorer
    public partial class _DockableWindowHost : UserControl
    {
        public const string ProgId = "SlimDucky.DockableWindowHost";
        public const string Guid = "F6F1B4EC-9A1E-4311-91C2-D79A6A6F047E";

        // ReSharper disable UnusedAutoPropertyAccessor.Local
        [StructLayout(LayoutKind.Sequential)]
        private struct Rect
        {
            public int Left { get; set; }
            public int Top { get; set; }
            public int Right { get; set; }
            public int Bottom { get; set; }
        }
        // ReSharper restore UnusedAutoPropertyAccessor.Local

        [StructLayout(LayoutKind.Explicit)]
        private struct LParam
        {
            [FieldOffset(0)]
            public uint Value;
            [FieldOffset(0)]
            public readonly ushort LowWord;
            [FieldOffset(2)]
            public readonly ushort HighWord;
        }

        [DllImport("User32.dll")]
        static extern IntPtr GetParent(IntPtr hWnd);

        [DllImport("User32.dll", EntryPoint = "GetClientRect")]
        static extern int GetClientRect(IntPtr hWnd, ref Rect lpRect);

        private IntPtr _parentHandle;
        //private ParentWindow _subClassingWindow;
        //private GCHandle _thisHandle;

        internal void AddUserControl(UserControl control, IntPtr vbeHwnd)
        {
            _parentHandle = GetParent(Handle);
            //_subClassingWindow = new ParentWindow(vbeHwnd, new IntPtr(GetHashCode()), _parentHandle);
            //_subClassingWindow.CallBackEvent += OnCallBackEvent;

            ////DO NOT REMOVE THIS CALL. Dockable windows are instantiated by the VBE, not directly by RD.  On top of that,
            ////since we have to inherit from UserControl we don't have to keep handling window messages until the VBE gets
            ////around to destroying the control's host or it results in an access violation when the base class is disposed.
            ////We need to manually call base.Dispose() ONLY in response to a WM_DESTROY message.
            //_thisHandle = GCHandle.Alloc(this, GCHandleType.Normal);

            if(control != null)
            {
                control.Dock = DockStyle.Fill;
                Controls.Add(control);
            }
            AdjustSize();
        }

        //private void OnCallBackEvent(object sender, SubClassingWindowEventArgs e)
        //{
        //    if(!e.Closing)
        //    {
        //        var param = new LParam { Value = (uint)e.LParam };
        //        Size = new Size(param.LowWord, param.HighWord);
        //    }
        //    else
        //    {
        //        Debug.WriteLine("DockableWindowHost removed event handler.");
        //        _subClassingWindow.CallBackEvent -= OnCallBackEvent;
        //    }
        //}

        private void AdjustSize()
        {
            var rect = new Rect();
            if(GetClientRect(_parentHandle, ref rect) != 0)
            {
                Size = new Size(rect.Right - rect.Left, rect.Bottom - rect.Top);
            }
        }

        //protected override bool ProcessKeyPreview(ref Message m)
        //{
        //    const int wmKeydown = 0x100;
        //    var result = false;

        //    var hostedUserControl = (UserControl)Controls[0];

        //    if(m.Msg == wmKeydown)
        //    {
        //        var pressedKey = (Keys)m.WParam;
        //        switch(pressedKey)
        //        {
        //            case Keys.Tab:
        //                switch(ModifierKeys)
        //                {
        //                    case Keys.None:
        //                        SelectNextControl(hostedUserControl.ActiveControl, true, true, true, true);
        //                        result = true;
        //                        break;
        //                    case Keys.Shift:
        //                        SelectNextControl(hostedUserControl.ActiveControl, false, true, true, true);
        //                        result = true;
        //                        break;
        //                }
        //                break;
        //            case Keys.Return:
        //                if(hostedUserControl.ActiveControl.GetType() == typeof(Button))
        //                {
        //                    var activeButton = (Button)hostedUserControl.ActiveControl;
        //                    activeButton.PerformClick();
        //                }
        //                break;
        //        }
        //    }

        //    if(!result)
        //    {
        //        result = base.ProcessKeyPreview(ref m);
        //    }
        //    return result;
        //}

        //protected override void DefWndProc(ref Message m)
        //{
        //    //See the comment in the ctor for why we have to listen for this.
        //    if(m.Msg == (int)WM.DESTROY)
        //    {
        //        Debug.WriteLine("DockableWindowHost received WM.DESTROY.");
        //        _thisHandle.Free();
        //    }
        //    base.DefWndProc(ref m);
        //}

        //override 

        //public void Release()
        //{
        //    Debug.WriteLine("DockableWindowHost release called.");
        //    _subClassingWindow.Dispose();
        //}

        //protected override void DestroyHandle()
        //{
        //    Debug.WriteLine("DockableWindowHost DestroyHandle called.");
        //    base.DestroyHandle();
        //}

        [ComVisible(false)]
        public class ParentWindow : SubclassingWindow
        {
            public event SubClassingWindowEventHandler CallBackEvent;
            public delegate void SubClassingWindowEventHandler(object sender, SubClassingWindowEventArgs e);

            private readonly IntPtr _vbeHwnd;

            private void OnCallBackEvent(SubClassingWindowEventArgs e)
            {
                CallBackEvent?.Invoke(this, e);
            }

            public ParentWindow(IntPtr vbeHwnd, IntPtr id, IntPtr handle) : base(id, handle)
            {
                _vbeHwnd = vbeHwnd;
            }

            private bool _closing;
            public override int SubClassProc(IntPtr hWnd, IntPtr msg, IntPtr wParam, IntPtr lParam, IntPtr uIdSubclass, IntPtr dwRefData)
            {
                switch((uint)msg)
                {
                    case (uint)WM.SIZE:
                        var args = new SubClassingWindowEventArgs(lParam);
                        if(!_closing)
                            OnCallBackEvent(args);
                        break;
                    case (uint)WM.SETFOCUS:
                        if(!_closing)
                            User32.SendMessage(_vbeHwnd, WM.RUBBERDUCK_CHILD_FOCUS, Hwnd, Hwnd);
                        break;
                    case (uint)WM.KILLFOCUS:
                        if(!_closing)
                            User32.SendMessage(_vbeHwnd, WM.RUBBERDUCK_CHILD_FOCUS, Hwnd, IntPtr.Zero);
                        break;
                    case (uint)WM.RUBBERDUCK_SINKING:
                        OnCallBackEvent(new SubClassingWindowEventArgs(lParam) { Closing = true });
                        _closing = true;
                        break;
                }
                return base.SubClassProc(hWnd, msg, wParam, lParam, uIdSubclass, dwRefData);
            }
        }
    }
}