Merge pull request #4573 from mansellan/4555

Fix for High-DPI bug

Author: retailcoder

Rubberduck.Core/Common/IOperatingSystem.cs

@@ -3,5 +3,6 @@
     public interface IOperatingSystem
     {
         void ShowFolder(string folderPath);
+        WindowsVersion? GetOSVersion();
     }
 }

Rubberduck.Core/Common/WinAPI/SHCore.cs

@@ -0,0 +1,44 @@
+using System.Runtime.InteropServices;
+
+namespace Rubberduck.Common.WinAPI
+{
+    /// <summary>
+    /// Native functions from SHCore.dll
+    /// </summary>
+    public static class SHCore
+    {
+        /// <summary>
+        /// Sets the DPI awareness level of the current process.
+        /// </summary>
+        /// <param name="awareness">DPI awareness level.</param>
+        /// <returns>HRESULT of S_OK, E_INVALIDARG or E_ACCESSDENIED.</returns>
+        /// <remarks>
+        /// Only the first DPI awareness call made by a process will have effect, subsequent calls are disregarded.
+        /// Thus, calling this method before WPF loads will override the default WPF DPI awareness behavior.
+        /// </remarks>
+        [DllImport("SHCore.dll", SetLastError = true)]
+        public static extern bool SetProcessDpiAwareness(PROCESS_DPI_AWARENESS awareness);
+    }
+
+    /// <summary>
+    /// Describes DPI awareness of a process.
+    /// </summary>
+    public enum PROCESS_DPI_AWARENESS
+    {
+        /// <summary>
+        /// Process is not DPI aware. 
+        /// </summary>
+        Process_DPI_Unaware = 0,
+
+        /// <summary>
+        /// Process is aware of the System DPI (monitor 1).
+        /// </summary>
+        Process_System_DPI_Aware = 1,
+
+        /// <summary>
+        /// Process is aware of the DPI of individual monitors.
+        /// </summary>
+        Process_Per_Monitor_DPI_Aware = 2
+    }
+
+}

Rubberduck.Core/Common/WindowsOperatingSystem.cs

@@ -1,18 +1,56 @@
-using System.Diagnostics;
+using System;
+using System.Diagnostics;
 using System.IO;
+using System.Management;
+using System.Runtime.CompilerServices;
+using NLog;
 
 namespace Rubberduck.Common
 {
     public sealed class WindowsOperatingSystem : IOperatingSystem
     {
+        public static readonly ILogger _Logger = LogManager.GetCurrentClassLogger(); 
+
         public void ShowFolder(string folderPath)
         {
             if (!Directory.Exists(folderPath))
             {
                 Directory.CreateDirectory(folderPath);
             }
 
-            using (Process.Start(folderPath)) { }
+            using (Process.Start(folderPath))
+            {
+            }
+        }
+
+
+        public WindowsVersion? GetOSVersion()
+        {
+            try
+            {
+                var wmiEnum = new ManagementObjectSearcher("root\\CIMV2", "SELECT Version FROM  Win32_OperatingSystem")
+                    .Get().GetEnumerator();
+                wmiEnum.MoveNext();
+                var versionString = wmiEnum.Current.Properties["Version"].Value as string;
+
+                var versionElements = versionString?.Split('.');
+
+                if (versionElements?.Length >= 3 &&
+                    int.TryParse(versionElements[0], out var major) &&
+                    int.TryParse(versionElements[1], out var minor) &&
+                    int.TryParse(versionElements[2], out var build))
+                {
+                    return new WindowsVersion(major, minor, build);
+                }                
+            }
+            catch (Exception exception)
+            {
+                _Logger.Warn(exception, "Unable to determine OS Version");
+                return null;
+            }
+            _Logger.Warn("Unable to determine OS Version");
+            return null;
         }
     }
 }
+

Rubberduck.Core/Common/WindowsVersion.cs

@@ -0,0 +1,91 @@
+using System;
+
+namespace Rubberduck.Common
+{
+    public struct WindowsVersion : IComparable<WindowsVersion>, IEquatable<WindowsVersion>
+    {
+        public static readonly WindowsVersion Windows10 = new WindowsVersion(10, 0, 10240);
+        public static readonly WindowsVersion Windows81 = new WindowsVersion(6, 3, 9200);
+        public static readonly WindowsVersion Windows8 = new WindowsVersion(6, 2, 9200);
+        public static readonly WindowsVersion Windows7_SP1 = new WindowsVersion(6, 1, 7601);
+        public static readonly WindowsVersion WindowsVista_SP2 = new WindowsVersion(6, 0, 6002);
+
+        public WindowsVersion(int major, int minor, int build)
+        {
+            Major = major;
+            Minor = minor;
+            Build = build;
+        }
+
+        public int Major { get; }
+        public int Minor { get; }
+        public int Build { get; }
+
+
+        public int CompareTo(WindowsVersion other)
+        {
+            var majorComparison = Major.CompareTo(other.Major);
+            if (majorComparison != 0)
+            {
+                return majorComparison;
+            }
+
+            var minorComparison = Minor.CompareTo(other.Minor);
+
+            return minorComparison != 0
+                ? minorComparison
+                : Build.CompareTo(other.Build);
+        }
+
+        public bool Equals(WindowsVersion other)
+        {
+            return Major == other.Major && Minor == other.Minor && Build == other.Build;
+        }
+
+        public override bool Equals(object other)
+        {
+            return other is WindowsVersion otherVersion && Equals(otherVersion);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = Major;
+                hashCode = (hashCode * 397) ^ Minor;
+                hashCode = (hashCode * 397) ^ Build;
+                return hashCode;
+            }
+        }
+
+        public static bool operator ==(WindowsVersion os1, WindowsVersion os2)
+        {
+            return os1.CompareTo(os2) == 0;
+        }
+
+        public static bool operator !=(WindowsVersion os1, WindowsVersion os2)
+        {
+            return os1.CompareTo(os2) != 0;
+        }
+
+        public static bool operator <(WindowsVersion os1, WindowsVersion os2)
+        {
+            return os1.CompareTo(os2) < 0;
+        }
+
+        public static bool operator >(WindowsVersion os1, WindowsVersion os2)
+        {
+            return os1.CompareTo(os2) > 0;
+        }
+
+        public static bool operator <=(WindowsVersion os1, WindowsVersion os2)
+        {
+            return os1.CompareTo(os2) <= 0;
+        }
+
+        public static bool operator >=(WindowsVersion os1, WindowsVersion os2)
+        {
+            return os1.CompareTo(os2) >= 0;
+        }
+    }
+}

Rubberduck.Core/Rubberduck.Core.csproj

@@ -29,6 +29,7 @@
     <Reference Include="PresentationCore" />
     <Reference Include="PresentationFramework" />
     <Reference Include="PresentationFramework.Aero" />
+    <Reference Include="System.Management" />
     <Reference Include="System.Net.Http" />
     <Reference Include="System.Windows.Forms" />
     <Reference Include="System.Xaml" />

Rubberduck.Core/Settings/GeneralSettings.cs

@@ -18,6 +18,7 @@ public interface IGeneralSettings
         int AutoSavePeriod { get; set; }
         bool UserEditedLogLevel { get; set; }
         int MinimumLogLevel { get; set; }
+        bool SetDpiUnaware { get; set; }
         List<ExperimentalFeatures> EnableExperimentalFeatures { get; set; }
     }
 
@@ -56,6 +57,8 @@ public int MinimumLogLevel
             }
         }
 
+        public bool SetDpiUnaware { get; set; }
+
         public List<ExperimentalFeatures> EnableExperimentalFeatures { get; set; } = new List<ExperimentalFeatures>();
 
         public GeneralSettings()
@@ -79,7 +82,8 @@ public bool Equals(GeneralSettings other)
                    UserEditedLogLevel == other.UserEditedLogLevel &&
                    MinimumLogLevel == other.MinimumLogLevel &&
                    EnableExperimentalFeatures.All(a => other.EnableExperimentalFeatures.Contains(a)) &&
-                   EnableExperimentalFeatures.Count == other.EnableExperimentalFeatures.Count;
+                   EnableExperimentalFeatures.Count == other.EnableExperimentalFeatures.Count &&
+                   SetDpiUnaware == other.SetDpiUnaware;
         }
     }
 }

Rubberduck.Core/UI/Settings/GeneralSettings.xaml

@@ -131,6 +131,8 @@
                               IsChecked="{Binding CheckVersionAtStartup}" />
                     <CheckBox Margin="5,0,0,5" Content="{Resx ResxName=Rubberduck.Resources.RubberduckUI, Key=GeneralSettings_CompileBeforeParse}"
                               IsChecked="{Binding CompileBeforeParse}" />
+                    <CheckBox Margin="5,0,0,5" Content="{Resx ResxName=Rubberduck.Resources.RubberduckUI, Key=GeneralSettings_SetDpiUnaware}"
+                              IsEnabled="{Binding SetDpiUnawareEnabled}"  IsChecked="{Binding SetDpiUnaware}" />
                     <StackPanel Orientation="Horizontal"/>
 
                     <Label Content="{Resx ResxName=Rubberduck.Resources.RubberduckUI, Key=GeneralSettings_MinimumLogLevelLabel}" FontWeight="SemiBold" />

Rubberduck.Core/UI/Settings/GeneralSettingsViewModel.cs

@@ -158,6 +158,29 @@ public bool CompileBeforeParse
             }
         }
 
+        private bool _setDpiUnaware;
+        public bool SetDpiUnaware
+        {
+            get => _setDpiUnaware;
+            set
+            {
+                if (_setDpiUnaware != value)
+                {
+                    _setDpiUnaware = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+
+        public bool SetDpiUnawareEnabled
+        {
+            get
+            {
+                var osVersion = _operatingSystem.GetOSVersion();
+                return osVersion != null && osVersion >= WindowsVersion.Windows81;
+            }
+        }
+
         private bool SynchronizeVBESettings()
         {
             if (!_messageBox.ConfirmYesNo(RubberduckUI.GeneralSettings_CompileBeforeParse_WarnCompileOnDemandEnabled,
@@ -243,6 +266,7 @@ private Rubberduck.Settings.GeneralSettings GetCurrentGeneralSettings()
                 CanShowSplash = ShowSplashAtStartup,
                 CanCheckVersion = CheckVersionAtStartup,
                 CompileBeforeParse = CompileBeforeParse,
+                SetDpiUnaware =  SetDpiUnaware,
                 IsSmartIndenterPrompted = _indenterPrompted,
                 IsAutoSaveEnabled = AutoSaveEnabled,
                 AutoSavePeriod = AutoSavePeriod,
@@ -259,6 +283,7 @@ private void TransferSettingsToView(IGeneralSettings general, IHotkeySettings ho
             ShowSplashAtStartup = general.CanShowSplash;
             CheckVersionAtStartup = general.CanCheckVersion;
             CompileBeforeParse = general.CompileBeforeParse;
+            SetDpiUnaware = general.SetDpiUnaware;
             _indenterPrompted = general.IsSmartIndenterPrompted;
             AutoSaveEnabled = general.IsAutoSaveEnabled;
             AutoSavePeriod = general.AutoSavePeriod;

Rubberduck.Main/Extension.cs

@@ -12,6 +12,7 @@
 using System.Windows.Threading;
 using Castle.Windsor;
 using NLog;
+using Rubberduck.Common.WinAPI;
 using Rubberduck.Root;
 using Rubberduck.Resources;
 using Rubberduck.Resources.Registration;
@@ -160,6 +161,17 @@ private void InitializeAddIn()
                 catch (CultureNotFoundException)
                 {
                 }
+                try
+                {
+                    if (_initialSettings.SetDpiUnaware)
+                    {
+                        SHCore.SetProcessDpiAwareness(PROCESS_DPI_AWARENESS.Process_DPI_Unaware);
+                    }
+                }
+                catch (Exception)
+                {
+                    Debug.Assert(false, "Could not set DPI awareness.");
+                }
             }
             else
             {

Rubberduck.Resources/RubberduckUI.resx

@@ -1295,4 +1295,7 @@ NOTE: Restart is required for the setting to take effect.</value>
   <data name="TodoMarkerTodo" xml:space="preserve">
     <value>TODO</value>
   </data>
+  <data name="GeneralSettings_SetDpiUnaware" xml:space="preserve">
+    <value>Set DPI Unaware</value>
+  </data>
 </root>