Improved DPI Scaling on Windows and Fixed related Bugs

changes/2155.bugfix.rst

@@ -0,0 +1 @@
+DPI scaling on Windows is now improved and related bugs are fixed.

examples/window/window/app.py

@@ -19,10 +19,16 @@ def do_right(self, widget, **kwargs):
         self.main_window.position = (2000, 500)
 
     def do_left_current_screen(self, widget, **kwargs):
-        self.main_window.screen_position = (0, 100)
+        self.main_window.screen_position = (
+            self.main_window.screen.origin[0],
+            self.main_window.screen_position[1],
+        )
 
     def do_right_current_screen(self, widget, **kwargs):
-        self.main_window.screen_position = (1080, 100)
+        self.main_window.screen_position = (
+            self.main_window.screen.size[0] - self.main_window.size[0],
+            self.main_window.screen_position[1],
+        )
 
     def do_small(self, widget, **kwargs):
         self.main_window.size = (400, 300)

iOS/tests_backend/probe.py

@@ -1,7 +1,7 @@
 import asyncio
 
 import toga
-from toga_iOS.libs import NSRunLoop, UIScreen
+from toga_iOS.libs import NSRunLoop
 
 
 class BaseProbe:
@@ -21,5 +21,5 @@ async def redraw(self, message=None, delay=0):
 
     def assert_image_size(self, image_size, size, screen):
         # Retina displays render images at a higher resolution than their reported size.
-        scale = int(UIScreen.mainScreen.scale)
+        scale = int(screen._impl.native.scale)
         assert image_size == (size[0] * scale, size[1] * scale)

testbed/tests/app/test_app.py

@@ -603,3 +603,127 @@ async def test_app_icon(app, app_probe):
     app.icon = toga.Icon.APP_ICON
     await app_probe.redraw("Revert app icon to default")
     app_probe.assert_app_icon(None)
+
+
+# This test is windows specific
+if toga.platform.current_platform == "windows":
+
+    async def test_system_dpi_change(
+        monkeypatch, app, app_probe, main_window, main_window_probe
+    ):
+        main_window.toolbar.add(app.cmd1, app.cmd2)
+        main_window.content.add(
+            toga.Button(text="Testing for system DPI change response")
+        )
+        await main_window_probe.redraw(
+            "Main Window is ready for testing system DPI change response"
+        )
+        # Store original values
+        original_sizes = dict()
+        original_sizes[main_window._impl.native.MainMenuStrip] = (
+            main_window._impl.scale_out(
+                main_window._impl.native.MainMenuStrip.Size.Width
+            ),
+            main_window._impl.scale_out(
+                main_window._impl.native.MainMenuStrip.Size.Height
+            ),
+        )
+        original_sizes[main_window._impl.toolbar_native] = (
+            main_window._impl.scale_out(main_window._impl.toolbar_native.Size.Width),
+            main_window._impl.scale_out(main_window._impl.toolbar_native.Size.Height),
+        )
+        for widget in app.widgets:
+            original_sizes[widget] = (
+                widget.window._impl.scale_out(widget._impl.native.Size.Width),
+                widget.window._impl.scale_out(widget._impl.native.Size.Height),
+            )
+
+        from toga_winforms.libs import shcore
+
+        GetScaleFactorForMonitor_original = getattr(shcore, "GetScaleFactorForMonitor")
+
+        for dpi_change_event in {
+            app._impl.winforms_DisplaySettingsChanged,
+            main_window._impl.winforms_LocationChanged,
+            main_window._impl.winforms_Resize,
+        }:
+            for pScale_value_mock in [1.0, 1.25, 1.5, 1.75, 2.0]:
+
+                def GetScaleFactorForMonitor_mock(hMonitor, pScale):
+                    pScale.value = int(pScale_value_mock * 100)
+
+                monkeypatch.setattr(
+                    "toga_winforms.libs.shcore.GetScaleFactorForMonitor",
+                    GetScaleFactorForMonitor_mock,
+                )
+                # Trigger DPI change event
+                dpi_change_event(None, None)
+                await main_window_probe.redraw(
+                    "Triggering DPI change event for testing property changes"
+                )
+                # Check that the screen dpi scale returns the mocked value
+                assert app.screens[0]._impl.dpi_scale == pScale_value_mock
+
+                # Check MenuBar Font Scaling
+                assert (
+                    main_window._impl.native.MainMenuStrip.Font.Size
+                    == main_window._impl.scale_font(
+                        main_window._impl.original_menubar_font
+                    ).Size
+                )
+                assert (
+                    main_window._impl.native.MainMenuStrip.Size.Width,
+                    main_window._impl.native.MainMenuStrip.Size.Height,
+                ) == (
+                    main_window._impl.scale_in(
+                        original_sizes[main_window._impl.native.MainMenuStrip][0]
+                    ),
+                    main_window._impl.scale_in(
+                        original_sizes[main_window._impl.native.MainMenuStrip][1]
+                    ),
+                )
+                # Check ToolBar Font Scaling and Size
+                assert (
+                    main_window._impl.toolbar_native.Font.Size
+                    == main_window._impl.scale_font(
+                        main_window._impl.original_toolbar_font
+                    ).Size
+                )
+                assert (
+                    main_window._impl.toolbar_native.Size.Width,
+                    main_window._impl.toolbar_native.Size.Height,
+                ) == (
+                    main_window._impl.scale_in(
+                        original_sizes[main_window._impl.toolbar_native][0]
+                    ),
+                    main_window._impl.scale_in(
+                        original_sizes[main_window._impl.toolbar_native][1]
+                    ),
+                )
+
+                # Check Widget Font Scaling and Size
+                for widget in app.widgets:
+                    assert (
+                        widget._impl.native.Font.Size
+                        == widget.window._impl.scale_font(
+                            widget._impl.original_font
+                        ).Size
+                    )
+                    assert (
+                        widget._impl.native.Size.Width,
+                        widget._impl.native.Size.Height,
+                    ) == (
+                        main_window._impl.scale_in(original_sizes[widget][0]),
+                        main_window._impl.scale_in(original_sizes[widget][1]),
+                    )
+
+        monkeypatch.setattr(
+            "toga_winforms.libs.shcore.GetScaleFactorForMonitor",
+            GetScaleFactorForMonitor_original,
+        )
+        await main_window_probe.redraw(
+            "Triggering DPI change event for restoring original state"
+        )
+        app._impl.winforms_DisplaySettingsChanged(None, None)
+        main_window.content.clear()
+        main_window.toolbar.clear()

winforms/src/toga_winforms/__init__.py

@@ -2,6 +2,11 @@
 
 import toga
 
+from .libs.user32 import (
+    DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2,
+    SetProcessDpiAwarenessContext,
+)
+
 # Add a reference to the Winforms assembly
 clr.AddReference("System.Windows.Forms")
 
@@ -16,4 +21,19 @@
     "WindowsBase, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
 )
 
+
+# Enable DPI awareness. This must be done before calling any other UI-related code
+# (https://learn.microsoft.com/en-us/dotnet/desktop/winforms/high-dpi-support-in-windows-forms).
+import System.Windows.Forms as WinForms  # noqa: E402
+
+WinForms.Application.EnableVisualStyles()
+WinForms.Application.SetCompatibleTextRenderingDefault(False)
+
+if SetProcessDpiAwarenessContext is not None:
+    if not SetProcessDpiAwarenessContext(
+        DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2
+    ):  # pragma: no cover
+        print("WARNING: Failed to set the DPI Awareness mode for the app.")
+
+
 __version__ = toga._package_version(__file__, __name__)

winforms/src/toga_winforms/app.py

@@ -2,10 +2,10 @@
 import re
 import sys
 import threading
-from ctypes import windll
 
 import System.Windows.Forms as WinForms
-from System import Environment, Threading
+from Microsoft.Win32 import SystemEvents
+from System import Threading
 from System.ComponentModel import InvalidEnumArgumentException
 from System.Media import SystemSounds
 from System.Net import SecurityProtocolType, ServicePointManager
@@ -18,7 +18,7 @@
 from .keys import toga_to_winforms_key, toga_to_winforms_shortcut
 from .libs.proactor import WinformsProactorEventLoop
 from .libs.wrapper import WeakrefCallable
-from .screens import Screen as ScreenImpl
+from .screens import Screen
 from .window import Window
 
 
@@ -33,6 +33,13 @@ def winforms_FormClosing(self, sender, event):
             self.interface.app.on_exit()
             event.Cancel = True
 
+    def update_dpi(self):
+        super().update_dpi()
+        if (
+            getattr(self, "original_menubar_font", None) is not None
+        ):  # pragma: no branch
+            self.native.MainMenuStrip.Font = self.scale_font(self.original_menubar_font)
+
 
 def winforms_thread_exception(sender, winforms_exc):  # pragma: no cover
     # The PythonException returned by Winforms doesn't give us
@@ -97,32 +104,10 @@ def create(self):
         self.app_context = WinForms.ApplicationContext()
         self.app_dispatcher = Dispatcher.CurrentDispatcher
 
-        # Check the version of windows and make sure we are setting the DPI mode
-        # with the most up to date API
-        # Windows Versioning Check Sources : https://www.lifewire.com/windows-version-numbers-2625171
-        # and https://docs.microsoft.com/en-us/windows/release-information/
-        win_version = Environment.OSVersion.Version
-        if win_version.Major >= 6:  # Checks for Windows Vista or later
-            # Represents Windows 8.1 up to Windows 10 before Build 1703 which should use
-            # SetProcessDpiAwareness(True)
-            if (win_version.Major == 6 and win_version.Minor == 3) or (
-                win_version.Major == 10 and win_version.Build < 15063
-            ):  # pragma: no cover
-                windll.shcore.SetProcessDpiAwareness(True)
-                print(
-                    "WARNING: Your Windows version doesn't support DPI-independent rendering.  "
-                    "We recommend you upgrade to at least Windows 10 Build 1703."
-                )
-            # Represents Windows 10 Build 1703 and beyond which should use
-            # SetProcessDpiAwarenessContext(-2)
-            elif win_version.Major == 10 and win_version.Build >= 15063:
-                windll.user32.SetProcessDpiAwarenessContext(-2)
-            # Any other version of windows should use SetProcessDPIAware()
-            else:  # pragma: no cover
-                windll.user32.SetProcessDPIAware()
-
-        self.native.EnableVisualStyles()
-        self.native.SetCompatibleTextRenderingDefault(False)
+        # Register the DisplaySettingsChanged event handler
+        SystemEvents.DisplaySettingsChanged += WeakrefCallable(
+            self.winforms_DisplaySettingsChanged
+        )
 
         # Ensure that TLS1.2 and TLS1.3 are enabled for HTTPS connections.
         # For some reason, some Windows installs have these protocols
@@ -150,6 +135,14 @@ def create(self):
         self.create_menus()
         self.interface.main_window._impl.set_app(self)
 
+    ######################################################################
+    # Native event handlers
+    ######################################################################
+
+    def winforms_DisplaySettingsChanged(self, sender, event):
+        for window in self.interface.windows:
+            window._impl.update_dpi()
+
     ######################################################################
     # Commands and menus
     ######################################################################
@@ -257,6 +250,8 @@ def create_menus(self):
                 cmd._impl.native.append(item)
                 submenu.DropDownItems.Add(item)
 
+        # Required for font scaling on DPI changes
+        window.original_menubar_font = menubar.Font
         window.resize_content()
 
     ######################################################################
@@ -313,9 +308,9 @@ def set_main_window(self, window):
     ######################################################################
 
     def get_screens(self):
-        primary_screen = ScreenImpl(WinForms.Screen.PrimaryScreen)
+        primary_screen = Screen(WinForms.Screen.PrimaryScreen)
         screen_list = [primary_screen] + [
-            ScreenImpl(native=screen)
+            Screen(native=screen)
             for screen in WinForms.Screen.AllScreens
             if screen != primary_screen.native
         ]

winforms/src/toga_winforms/container.py

@@ -6,14 +6,23 @@
 
 class Container(Scalable):
     def __init__(self, native_parent):
-        self.init_scale(native_parent)
         self.native_parent = native_parent
         self.native_width = self.native_height = 0
         self.content = None
 
         self.native_content = WinForms.Panel()
         native_parent.Controls.Add(self.native_content)
 
+        self.native_content.CreateGraphics().Dispose()
+
+    @property
+    def dpi_scale(self):
+        window = self.content.interface.window
+        if window:
+            return window._impl.dpi_scale
+        else:
+            return 1
+
     @property
     def width(self):
         return self.scale_out(self.native_width)