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.

core/src/toga/types.py

@@ -29,7 +29,7 @@ def __str__(self) -> str:
 
 
 class Position(NamedTuple):
-    """A 2D window position."""
+    """A 2D position."""
 
     #: X coordinate, in CSS pixels.
     x: int
@@ -46,15 +46,21 @@ def __add__(self, other):
     def __sub__(self, other):
         return Position(self.x - other.x, self.y - other.y)
 
+    def __mul__(self, other):
+        return Position(self.x * other, self.y * other)
+
 
 class Size(NamedTuple):
-    """A 2D window size."""
+    """A 2D size."""
 
-    #: Width
+    #: Width, in CSS pixels.
     width: int
 
-    #: Height
+    #: Height, in CSS pixels.
     height: int
 
     def __str__(self) -> str:
         return f"({self.width} x {self.height})"
+
+    def __mul__(self, other):
+        return Size(self.width * other, self.height * other)

core/tests/test_types.py

@@ -7,7 +7,12 @@ def test_position_properties():
     assert p.x == 1
     assert p.y == 2
     assert str(p) == "(1, 2)"
-    p == (1, 2)  # Tuple equivalence for backwards-compatibility
+
+    assert p == Position(1, 2)
+    assert p != Position(1, 3)
+
+    assert p == (1, 2)  # Tuple equivalence for backwards-compatibility
+    assert p != (1, 3)
 
 
 def test_add_positions():
@@ -20,10 +25,26 @@ def test_sub_positions():
     assert Position(1, 2) - Position(3, 4) == Position(-2, -2)
 
 
+def test_mul_position():
+    """Multiplying a Position multiplies its X and Y values"""
+    assert Position(1, 2) * 2 == Position(2, 4)
+    assert Position(1, 2) * 0.5 == Position(0.5, 1)
+    assert Position(1, 2) * 0 == Position(0, 0)
+    assert Position(1, 2) * -1 == Position(-1, -2)
+
+
 def test_size_properties():
     """A Size NamedTuple has a width and height."""
     s = Size(1, 2)
     assert s.width == 1
     assert s.height == 2
     assert str(s) == "(1 x 2)"
     s == (1, 2)  # Tuple equivalence for backwards-compatibility
+
+
+def test_mul_size():
+    """Multiplying a Size multiplies its width and height values"""
+    assert Size(1, 2) * 2 == Size(2, 4)
+    assert Size(1, 2) * 0.5 == Size(0.5, 1)
+    assert Size(1, 2) * 0 == Size(0, 0)
+    assert Size(1, 2) * -1 == Size(-1, -2)

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.x,
+            self.main_window.screen_position.y,
+        )
 
     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.width - self.main_window.size.width,
+            self.main_window.screen_position.y,
+        )
 
     def do_small(self, widget, **kwargs):
         self.main_window.size = (400, 300)

testbed/tests/app/test_desktop.py

@@ -1,8 +1,10 @@
+from functools import partial
 from unittest.mock import Mock
 
 import pytest
 
 import toga
+from toga import Position, Size
 from toga.colors import CORNFLOWERBLUE, FIREBRICK, REBECCAPURPLE
 from toga.style.pack import Pack
 
@@ -391,6 +393,171 @@ async def test_current_window(app, app_probe, main_window):
         assert app.current_window == window3
 
 
+@pytest.mark.parametrize(
+    "event_path",
+    [
+        "SystemEvents.DisplaySettingsChanged",
+        "Form.LocationChanged",
+        "Form.Resize",
+    ],
+)
+@pytest.mark.parametrize("mock_scale", [1.0, 1.25, 1.5, 1.75, 2.0])
+async def test_system_dpi_change(
+    main_window, main_window_probe, event_path, mock_scale
+):
+    if toga.platform.current_platform != "windows":
+        pytest.xfail("This test is winforms backend specific")
+
+    from toga_winforms.libs import shcore
+
+    real_scale = main_window_probe.scale_factor
+    if real_scale == mock_scale:
+        pytest.skip("mock scale and real scale are the same")
+    scale_change = mock_scale / real_scale
+    content_size = main_window_probe.content_size
+
+    original_content = main_window.content
+    GetScaleFactorForMonitor_original = shcore.GetScaleFactorForMonitor
+    dpi_change_event = find_event(event_path, main_window_probe)
+
+    try:
+        # Include widgets which are sized in different ways, with padding and fixed
+        # sizes in both dimensions.
+        main_window.content = toga.Box(
+            style=Pack(direction="row"),
+            children=[
+                toga.Label(
+                    "fixed",
+                    id="fixed",
+                    style=Pack(background_color="yellow", padding_left=20, width=100),
+                ),
+                toga.Label(
+                    "minimal",  # Shrink to fit content
+                    id="minimal",
+                    style=Pack(background_color="cyan", font_size=16),
+                ),
+                toga.Label(
+                    "flex",
+                    id="flex",
+                    style=Pack(
+                        background_color="pink", flex=1, padding_top=15, height=50
+                    ),
+                ),
+            ],
+        )
+        await main_window_probe.redraw("main_window is ready for testing")
+
+        ids = ["fixed", "minimal", "flex"]
+        probes = {id: get_probe(main_window.widgets[id]) for id in ids}
+
+        def get_metrics():
+            return (
+                {id: Position(probes[id].x, probes[id].y) for id in ids},
+                {id: Size(probes[id].width, probes[id].height) for id in ids},
+                {id: probes[id].font_size for id in ids},
+            )
+
+        positions, sizes, font_sizes = get_metrics()
+
+        # Because of hinting, font size changes can have non-linear effects on pixel
+        # sizes.
+        approx_fixed = partial(pytest.approx, abs=1)
+        approx_font = partial(pytest.approx, rel=0.25)
+
+        assert font_sizes["fixed"] == 9  # Default font size on Windows
+        assert positions["fixed"] == approx_fixed((20, 0))
+        assert sizes["fixed"].width == approx_fixed(100)
+
+        assert font_sizes["minimal"] == 16
+        assert positions["minimal"] == approx_fixed((120, 0))
+        assert sizes["minimal"].height == approx_font(sizes["fixed"].height * 16 / 9)
+
+        assert font_sizes["flex"] == 9
+        assert positions["flex"] == approx_fixed((120 + sizes["minimal"].width, 15))
+        assert sizes["flex"] == approx_fixed(
+            (content_size.width - positions["flex"].x, 50)
+        )
+
+        # Mock the function Toga uses to get the scale factor.
+        def GetScaleFactorForMonitor_mock(hMonitor, pScale):
+            pScale.value = int(mock_scale * 100)
+
+        # Set and Trigger dpi change event with the specified dpi scale
+        shcore.GetScaleFactorForMonitor = GetScaleFactorForMonitor_mock
+        dpi_change_event(None)
+        await main_window_probe.redraw(
+            f"Triggered dpi change event with {mock_scale} dpi scale"
+        )
+
+        # Check Widget size DPI scaling
+        positions_scaled, sizes_scaled, font_sizes_scaled = get_metrics()
+        for id in ids:
+            assert font_sizes_scaled[id] == approx_fixed(font_sizes[id] * scale_change)
+
+        assert positions_scaled["fixed"] == approx_fixed(Position(20, 0) * scale_change)
+        assert sizes_scaled["fixed"] == (
+            approx_fixed(100 * scale_change),
+            approx_font(sizes["fixed"].height * scale_change),
+        )
+
+        assert positions_scaled["minimal"] == approx_fixed(
+            Position(120, 0) * scale_change
+        )
+        assert sizes_scaled["minimal"] == approx_font(sizes["minimal"] * scale_change)
+
+        assert positions_scaled["flex"] == approx_fixed(
+            (
+                positions_scaled["minimal"].x + sizes_scaled["minimal"].width,
+                15 * scale_change,
+            )
+        )
+        assert sizes_scaled["flex"] == approx_fixed(
+            (
+                content_size.width - positions_scaled["flex"].x,
+                50 * scale_change,
+            )
+        )
+
+    finally:
+        # Restore original state
+        shcore.GetScaleFactorForMonitor = GetScaleFactorForMonitor_original
+        dpi_change_event(None)
+        await main_window_probe.redraw("Restored original state of main_window")
+        assert get_metrics() == (positions, sizes, font_sizes)
+        main_window.content = original_content
+
+
+def find_event(event_path, main_window_probe):
+    from Microsoft.Win32 import SystemEvents
+    from System import Array, Object
+    from System.Reflection import BindingFlags
+
+    event_class, event_name = event_path.split(".")
+    if event_class == "Form":
+        return getattr(main_window_probe.native, f"On{event_name}")
+
+    elif event_class == "SystemEvents":
+        # There are no "On" methods in this class, so we need to use reflection.
+        SystemEvents_type = SystemEvents().GetType()
+        binding_flags = BindingFlags.Static | BindingFlags.NonPublic
+        RaiseEvent = [
+            method
+            for method in SystemEvents_type.GetMethods(binding_flags)
+            if method.Name == "RaiseEvent" and len(method.GetParameters()) == 2
+        ][0]
+
+        event_key = SystemEvents_type.GetField(
+            f"On{event_name}Event", binding_flags
+        ).GetValue(None)
+
+        return lambda event_args: RaiseEvent.Invoke(
+            None, [event_key, Array[Object]([None, event_args])]
+        )
+
+    else:
+        raise AssertionError(f"unknown event class {event_class}")
+
+
 async def test_session_based_app(
     monkeypatch,
     app,

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,18 @@
     "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.Media import SystemSounds
 from System.Net import SecurityProtocolType, ServicePointManager
 from System.Windows.Threading import Dispatcher
@@ -76,32 +76,17 @@ 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)
+        # We would prefer to detect DPI changes directly, using the DpiChanged,
+        # DpiChangedBeforeParent or DpiChangedAfterParent events on the window. But none
+        # of these events ever fire, possibly because we're missing some app metadata
+        # (https://github.com/beeware/toga/pull/2155#issuecomment-2460374101). So
+        # instead we need to listen to all events which could cause a DPI change:
+        #   * DisplaySettingsChanged
+        #   * Form.LocationChanged and Form.Resize, since a window's DPI is determined
+        #     by which screen most of its area is on.
+        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
@@ -126,6 +111,19 @@ def create(self):
         # Populate the main window as soon as the event loop is running.
         self.loop.call_soon_threadsafe(self.interface._startup)
 
+    ######################################################################
+    # Native event handlers
+    ######################################################################
+
+    def winforms_DisplaySettingsChanged(self, sender, event):
+        # This event is NOT called on the UI thread, so it's not safe for it to access
+        # the UI directly.
+        self.interface.loop.call_soon_threadsafe(self.update_dpi)
+
+    def update_dpi(self):
+        for window in self.interface.windows:
+            window._impl.update_dpi()
+
     ######################################################################
     # Commands and menus
     ######################################################################