Merge branch 'next' into ResolveExpressionInNext

Author: MDoerner

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplicitDefaultMemberAccessInspection.cs

@@ -45,6 +45,7 @@ namespace Rubberduck.Inspections.Concrete
     ///     arg.ConnectionString = bar
     /// End Sub
     /// ]]>
+    /// </example>
     public sealed class ImplicitDefaultMemberAccessInspection : IdentifierReferenceInspectionBase
     {
         public ImplicitDefaultMemberAccessInspection(RubberduckParserState state)

Rubberduck.CodeAnalysis/Inspections/Concrete/ImplicitUnboundDefaultMemberAccessInspection.cs

@@ -24,6 +24,7 @@ namespace Rubberduck.Inspections.Concrete
     ///     bar = arg
     /// End Sub
     /// ]]>
+    /// </example>
     /// <example hasresult="true">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal arg As Object)
@@ -39,6 +40,7 @@ namespace Rubberduck.Inspections.Concrete
     ///     bar = arg.SomeValueReturningMember
     /// End Sub
     /// ]]>
+    /// </example>
     /// <example hasresult="false">
     /// <![CDATA[
     /// Public Sub DoSomething(ByVal arg As Object)

Rubberduck.Core/UI/Inspections/InspectionResultsControl.xaml

@@ -11,5 +11,10 @@ public InspectionResultsControl()
         {
             InitializeComponent();
         }
+
+        private void InspectionResultsGrid_RequestBringIntoView(object sender, System.Windows.RequestBringIntoViewEventArgs e)
+        {
+            e.Handled = true;
+        }
     }
 }

Rubberduck.Core/UI/Inspections/InspectionResultsControl.xaml.cs

@@ -0,0 +1,28 @@
+using System.Runtime.InteropServices.ComTypes;
+
+namespace Rubberduck.JunkDrawer.Hacks
+{
+    public static class VarDescExtensions
+    {
+        /// <remarks>
+        /// Use only with VBA-supplied <see cref="ITypeInfo"/> which may return a <see cref="VARDESC"/> that do not conform to 
+        /// the MS-OAUT in describing the constants. See section 2.2.43 at: https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-oaut/ae7791d2-4399-4dff-b7c6-b0d4f3dce982
+        /// 
+        /// To further complicate the situation, on 64-bit platform, the <see cref="VARDESC.DESCUNION.oInst"/> is a 32-bit integer whereas
+        /// the <see cref="VARDESC.DESCUNION.lpvarValue"/> is a pointer. On 32-bit platform, the sizes of 2 members are exactly same so no
+        /// problem. But on 64-bit platform, setting the <c>oInst</c>to 0 does not necessarily zero-initialize the entire region. Thus, the 
+        /// upper 32-bit part of the <c>lpvarValue</c> can contain garbage which will confound the simple null pointer check. Thus to guard 
+        /// against this, we will check the <c>oInst</c> value to see if it's zero. 
+        /// 
+        /// There is a small but non-zero chance that there might be a valid pointer that happens to be only in high half of the address...
+        /// in that case, it'll be wrong but since VBA is always writing <see cref="VARKIND.VAR_STATIC"/> to the <see cref="VARDESC.varkind"/>
+        /// field, we're kind of stuck...
+        /// </remarks>
+        /// <param name="varDesc">The <see cref="VARDESC"/> from a VBA <see cref="ITypeInfo"/></param>
+        /// <returns>True if this is most likely a constant. False when it's definitely not.</returns>
+        public static bool IsValidVBAConstant(this VARDESC varDesc)
+        {
+            return varDesc.varkind == VARKIND.VAR_STATIC && varDesc.desc.oInst != 0;
+        }
+    }
+}

Rubberduck.JunkDrawer/Hacks/VarDescExtensions.cs

@@ -4,6 +4,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Drawing;
 using System.Runtime.InteropServices;
+using System.Text;
 using System.Windows.Forms;
 using Rubberduck.VBEditor;
 using Rubberduck.VBEditor.WindowsApi;
@@ -145,7 +146,7 @@ private void RemoveChildControlsFromExposedControl()
         public int /* IOleObject:: */ Close([In] uint dwSaveOption)
         {
             _logger.Log(LogLevel.Trace, "IOleObject::Close() called");
-            int hr = _userControl.IOleObject.Close(dwSaveOption);
+            var hr = _userControl.IOleObject.Close(dwSaveOption);
 
             // IOleObject::SetClientSite is typically called with pClientSite = null just before calling IOleObject::Close()
             // If it didn't, we release all host COM objects here instead,
@@ -386,7 +387,7 @@ public void AddUserControl(UserControl control, IntPtr vbeHwnd)
 
             control.Dock = DockStyle.Fill;
             _userControl.Controls.Add(control);
-
+            
             AdjustSize();
         }
 
@@ -429,14 +430,79 @@ private void AdjustSize()
             }
         }
 
+        private static void ToggleDockable(IntPtr hWndVBE)
+        {
+            NativeMethods.SendMessage(hWndVBE, 0x1044, (IntPtr)0xB5, IntPtr.Zero);
+        }
+
         [ComVisible(false)]
         public class ParentWindow : SubclassingWindow
         {
+            private readonly Logger _logger = LogManager.GetCurrentClassLogger();
+
+            private const int MF_BYPOSITION = 0x400;
+
             public event SubClassingWindowEventHandler CallBackEvent;
             public delegate void SubClassingWindowEventHandler(object sender, SubClassingWindowEventArgs e);
 
             private readonly IntPtr _vbeHwnd;
 
+            private IntPtr _containerHwnd;
+            private ToolWindowState _windowState;
+            private IntPtr _menuHandle;
+
+            private enum ToolWindowState
+            {
+                Unknown,
+                Docked,
+                Floating,
+                Undockable
+            }
+
+            private ToolWindowState GetWindowState(IntPtr containerHwnd)
+            {
+                var className = new StringBuilder(255);
+                if (NativeMethods.GetClassName(containerHwnd, className, className.Capacity) > 0)
+                {
+                    switch (className.ToString())
+                    {
+                        case "wndclass_desked_gsk":
+                            return ToolWindowState.Docked;
+                        case "VBFloatingPalette":
+                            return ToolWindowState.Floating;
+                        case "DockingView":
+                            return ToolWindowState.Undockable;
+                    }
+                }
+
+                return ToolWindowState.Unknown;
+            }
+
+            private void DisplayUndockableContextMenu(IntPtr handle, IntPtr lParam)
+            {
+                if (_menuHandle == IntPtr.Zero)
+                {
+                    _menuHandle = NativeMethods.CreatePopupMenu();
+
+                    if (_menuHandle == IntPtr.Zero)
+                    {
+                        _logger.Warn("Cannot create menu handle");
+                        return;
+                    }
+
+                    if (!NativeMethods.InsertMenu(_menuHandle, 0, MF_BYPOSITION, (UIntPtr)WM.RUBBERDUCK_UNDOCKABLE_CONTEXT_MENU, "Dockable" + char.MinValue))
+                    {
+                        _logger.Warn("Failed to insert a menu item for dockable command");
+                    }
+                }
+
+                var param = new LParam {Value = (uint)lParam};
+                if (!NativeMethods.TrackPopupMenuEx(_menuHandle, 0x0, param.LowWord, param.HighWord, handle, IntPtr.Zero ))
+                {
+                    _logger.Warn("Failed to set the context menu for undockable tool windows");
+                };
+            }
+
             private void OnCallBackEvent(SubClassingWindowEventArgs e)
             {
                 CallBackEvent?.Invoke(this, e);
@@ -452,6 +518,28 @@ public override int SubClassProc(IntPtr hWnd, IntPtr msg, IntPtr wParam, IntPtr
             {
                 switch ((uint)msg)
                 {
+                    case (uint)WM.WINDOWPOSCHANGED:
+                        var containerHwnd = GetParent(hWnd);
+                        if (containerHwnd != _containerHwnd)
+                        {
+                            _containerHwnd = containerHwnd;
+                            _windowState = GetWindowState(_containerHwnd);
+                        }
+                        break;
+                    case (uint)WM.CONTEXTMENU:
+                        if (_windowState == ToolWindowState.Undockable)
+                        {
+                            DisplayUndockableContextMenu(hWnd, lParam);
+                        }
+                        break;
+                    case (uint)WM.COMMAND:
+                        switch (wParam.ToInt32())
+                        {
+                            case (int)WM.RUBBERDUCK_UNDOCKABLE_CONTEXT_MENU:
+                                ToggleDockable(_vbeHwnd);
+                                break;
+                        }
+                        break;
                     case (uint)WM.SIZE:
                         var args = new SubClassingWindowEventArgs(lParam);
                         if (!_closing) OnCallBackEvent(args);
@@ -462,6 +550,15 @@ public override int SubClassProc(IntPtr hWnd, IntPtr msg, IntPtr wParam, IntPtr
                     case (uint)WM.KILLFOCUS:
                         if (!_closing) User32.SendMessage(_vbeHwnd, WM.RUBBERDUCK_CHILD_FOCUS, Hwnd, IntPtr.Zero);
                         break;
+                    case (uint)WM.DESTROY:
+                        if (_menuHandle != IntPtr.Zero)
+                        {
+                            if (!NativeMethods.DestroyMenu(_menuHandle))
+                            {
+                                _logger.Fatal($"Failed to destroy the menu handle {_menuHandle}");
+                            }
+                        }
+                        break;
                 }
                 return base.SubClassProc(hWnd, msg, wParam, lParam, uIdSubclass, dwRefData);
             }

Rubberduck.Main/ComClientLibrary/UI/DockableWindowHost.cs

@@ -11,6 +11,8 @@
 using TYPEATTR = System.Runtime.InteropServices.ComTypes.TYPEATTR;
 using VARDESC = System.Runtime.InteropServices.ComTypes.VARDESC;
 using CALLCONV = System.Runtime.InteropServices.ComTypes.CALLCONV;
+using Rubberduck.VBEditor.ComManagement.TypeLibs.Abstract;
+using Rubberduck.JunkDrawer.Hacks;
 
 namespace Rubberduck.Parsing.ComReflection
 {
@@ -58,7 +60,15 @@ private void GetComFields(ITypeInfo info, TYPEATTR attrib)
                     info.GetNames(desc.memid, names, names.Length, out int length);
                     Debug.Assert(length == 1);
 
-                    var type = desc.desc.lpvarValue == IntPtr.Zero ? DeclarationType.Variable : DeclarationType.Constant;
+                    DeclarationType type;
+                    if(info is ITypeInfoWrapper wrapped && wrapped.HasVBEExtensions)
+                    {
+                        type = desc.IsValidVBAConstant() ? DeclarationType.Constant : DeclarationType.Variable;
+                    }
+                    else
+                    {
+                        type = desc.varkind == VARKIND.VAR_CONST ? DeclarationType.Constant : DeclarationType.Variable;
+                    }
 
                     _fields.Add(new ComField(this, info, names[0], desc, index, type));
                 }

Rubberduck.Parsing/ComReflection/ComModule.cs

@@ -1,6 +1,6 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Runtime.InteropServices.ComTypes;
+using Rubberduck.JunkDrawer.Hacks;
 using Rubberduck.VBEditor.ComManagement.TypeLibs.Abstract;
 using Rubberduck.VBEditor.ComManagement.TypeLibs.Unmanaged;
 using TYPEATTR = System.Runtime.InteropServices.ComTypes.TYPEATTR;
@@ -45,9 +45,8 @@ public TypeInfoConstantsCollection(ITypeInfo parent, TYPEATTR attributes) :
                 parent.GetVarDesc(i, out var ppVarDesc);
                 var varDesc = StructHelper.ReadStructureUnsafe<VARDESC>(ppVarDesc);
 
-                // VBA constants are "static".... go figure. We can still infer it is a 
-                // constant rather than a field by checking the lpvarValue
-                if (varDesc.varkind == VARKIND.VAR_STATIC && varDesc.desc.lpvarValue != IntPtr.Zero)
+                // VBA constants are "static".... go figure.
+                if (varDesc.IsValidVBAConstant())
                 {
                     _mapper.Add(_mapper.Count, i);
                 }

Rubberduck.VBEEditor/ComManagement/TypeLibs/TypeInfoConstantsCollection.cs

@@ -22,6 +22,7 @@
     <Reference Include="System.Windows.Forms" />
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\Rubberduck.JunkDrawer\Rubberduck.JunkDrawer.csproj" />
     <ProjectReference Include="..\Rubberduck.Resources\Rubberduck.Resources.csproj" />
   </ItemGroup>
   <ItemGroup>

Rubberduck.VBEEditor/Rubberduck.VBEditor.csproj

@@ -13,6 +13,18 @@ namespace Rubberduck.VBEditor.WindowsApi
     /// </remarks>
     public static class NativeMethods
     {
+        [DllImport("user32.dll")]
+        public static extern IntPtr CreatePopupMenu();
+
+        [DllImport("user32.dll")]
+        public static extern bool TrackPopupMenuEx(IntPtr hmenu, uint fuFlags, int x, int y, IntPtr hwnd, IntPtr lptpm);
+
+        [DllImport("user32.dll", EntryPoint = "InsertMenuW", SetLastError = true, CharSet = CharSet.Unicode)]
+        public static extern bool InsertMenu(IntPtr hMenu, uint wPosition, uint wFlags, UIntPtr wIDNewItem, [MarshalAs(UnmanagedType.LPWStr)]string lpNewItem);
+
+        [DllImport("user32.dll")]
+        public static extern bool DestroyMenu(IntPtr hMenu);
+
         /// <summary>   Sends a message to the OS. </summary>
         ///
         /// <param name="hWnd">     The window handle. </param>
@@ -68,6 +80,14 @@ public enum PeekMessageRemoval : uint
         [DllImport("user32", ExactSpelling = true, CharSet = CharSet.Unicode)]
         public static extern int EnumChildWindows(IntPtr parentWindowHandle, EnumChildWindowsDelegate lpEnumFunction, IntPtr lParam);
 
+        /// <summary> Retrieves the name of the class to which the specified window belongs. </summary>
+        /// <param name="hWnd">A handle to the window and, indirectly, the class to which the window belongs.</param>
+        /// <param name="lpClassName">The class name string.</param>
+        /// <param name="nMaxCount">The length of the <see cref="lpClassName" /> buffer, in characters. The buffer must be large enough to include the terminating null character; otherwise, the class name string is truncated to <see cref="nMaxCount" /> characters.</param>
+        /// <returns>If the function succeeds, the return value is the number of characters copied to the buffer, not including the terminating null character. If the function fails, the return value is zero.To get extended error information, call GetLastError.</returns>
+        [DllImport("user32.dll", EntryPoint = "GetClassNameW", SetLastError = true, CharSet = CharSet.Unicode)]
+        public static extern int GetClassName(IntPtr hWnd, StringBuilder lpClassName, int nMaxCount);
+
         /// <summary>   Gets window text. </summary>
         ///
         /// <param name="hWnd">         The window handle. </param>