Handle DPI changes in TkAgg backend on Windows.

QuLogic · QuLogic · commit 1b9dc952cc79 · 2021-04-22T23:10:57.000-04:00
diff --git a/lib/matplotlib/backends/_backend_tk.py b/lib/matplotlib/backends/_backend_tk.py
@@ -3,6 +3,7 @@
 import logging
 import math
 import os.path
+import queue
 import sys
 import tkinter as tk
 import tkinter.filedialog
@@ -409,6 +410,13 @@ def __init__(self, canvas, num, window):
             if self.toolbar:
                 backend_tools.add_tools_to_container(self.toolbar)
 
+        # If the window has per-monitor DPI awareness, then setup a poll to
+        # check the DPI change queue, to then update the scaling.
+        dpi_queue = queue.SimpleQueue()
+        if _tkagg.enable_dpi_awareness(int(window.frame(), 16), dpi_queue):
+            self._dpi_queue = dpi_queue
+            window.after(100, self._update_dpi_ratio)
+
         self._shown = False
 
     def _get_toolbar(self):
@@ -420,6 +428,24 @@ def _get_toolbar(self):
             toolbar = None
         return toolbar
 
+    def _update_dpi_ratio(self):
+        """
+        Polling function to update DPI ratio for Tk.
+
+        This must continuously check the queue, instead of waiting for a Tk
+        event, due to thread locking issues in the Python/Tk interface.
+        """
+        try:
+            newdpi = self._dpi_queue.get(block=False)
+        except queue.Empty:
+            self.window.after(100, self._update_dpi_ratio)
+            return
+        self.window.call('tk', 'scaling', newdpi / 72)
+        if self.toolbar and hasattr(self.toolbar, '_rescale'):
+            self.toolbar._rescale()
+        self.canvas._update_device_pixel_ratio()
+        self.window.after(100, self._update_dpi_ratio)
+
     def resize(self, width, height):
         max_size = 1_400_000  # the measured max on xorg 1.20.8 was 1_409_023
 
@@ -532,6 +558,32 @@ def __init__(self, canvas, window, *, pack_toolbar=True):
         if pack_toolbar:
             self.pack(side=tk.BOTTOM, fill=tk.X)
 
+    def _rescale(self):
+        """
+        Scale all children of the toolbar to current DPI setting.
+
+        Before this is called, the Tk scaling setting will have been updated to
+        match the new DPI. Tk widgets do not update for changes to scaling, but
+        all measurements made after the change will match the new scaling. Thus
+        this function re-applies all the same sizes in physical units (points),
+        which Tk will scale correctly to pixels.
+        """
+        for widget in self.winfo_children():
+            if isinstance(widget, (tk.Button, tk.Checkbutton)):
+                if hasattr(widget, '_image_file'):
+                    # Explicit class because ToolbarTk calls _rescale.
+                    NavigationToolbar2Tk._set_image_for_button(self, widget)
+                else:
+                    pass  # This is handled by the font setting instead.
+            elif isinstance(widget, tk.Frame):
+                widget.configure(height='22p', pady='1p')
+                widget.pack_configure(padx='4p')
+            elif isinstance(widget, tk.Label):
+                pass  # This is handled by the font setting instead.
+            else:
+                _log.warning('Unknown child class %s', widget.winfo_class)
+        self._label_font.configure(size=10)
+
     def _update_buttons_checked(self):
         # sync button checkstates to match active mode
         for text, mode in [('Zoom', _Mode.ZOOM), ('Pan', _Mode.PAN)]:
@@ -573,6 +625,22 @@ def set_cursor(self, cursor):
         except tkinter.TclError:
             pass
 
+    def _set_image_for_button(self, button):
+        """
+        Set the image for a button based on its pixel size.
+
+        The pixel size is determined by the DPI scaling of the window.
+        """
+        if button._image_file is None:
+            return
+
+        size = button.winfo_pixels('24p')
+        with Image.open(button._image_file.replace('.png', '_large.png')
+                        if size > 24 else button._image_file) as im:
+            image = ImageTk.PhotoImage(im.resize((size, size)), master=self)
+        button.configure(image=image, height='24p', width='24p')
+        button._ntimage = image  # Prevent garbage collection.
+
     def _Button(self, text, image_file, toggle, command):
         if not toggle:
             b = tk.Button(master=self, text=text, command=command)
@@ -587,14 +655,10 @@ def _Button(self, text, image_file, toggle, command):
                 master=self, text=text, command=command,
                 indicatoron=False, variable=var)
             b.var = var
+        b._image_file = image_file
         if image_file is not None:
-            size = b.winfo_pixels('24p')
-            with Image.open(image_file.replace('.png', '_large.png')
-                            if size > 24 else image_file) as im:
-                image = ImageTk.PhotoImage(im.resize((size, size)),
-                                           master=self)
-            b.configure(image=image, height='24p', width='24p')
-            b._ntimage = image  # Prevent garbage collection.
+            # Explicit class because ToolbarTk calls _Button.
+            NavigationToolbar2Tk._set_image_for_button(self, b)
         else:
             b.configure(font=self._label_font)
         b.pack(side=tk.LEFT)
@@ -748,6 +812,9 @@ def __init__(self, toolmanager, window):
         self.pack(side=tk.TOP, fill=tk.X)
         self._groups = {}
 
+    def _rescale(self):
+        return NavigationToolbar2Tk._rescale(self)
+
     def add_toolitem(
             self, name, group, position, image_file, description, toggle):
         frame = self._get_groupframe(group)
diff --git a/setupext.py b/setupext.py
@@ -444,8 +444,8 @@ def get_extensions(self):
             ],
             include_dirs=["src"],
             # psapi library needed for finding Tcl/Tk at run time.
-            libraries=({"linux": ["dl"], "win32": ["psapi"],
-                        "cygwin": ["psapi"]}.get(sys.platform, [])),
+            libraries={"linux": ["dl"], "win32": ["comctl32", "psapi"],
+                       "cygwin": ["comctl32", "psapi"]}.get(sys.platform, []),
             extra_link_args={"win32": ["-mwindows"]}.get(sys.platform, []))
         add_numpy_flags(ext)
         add_libagg_flags(ext)
diff --git a/src/_tkagg.cpp b/src/_tkagg.cpp
@@ -28,6 +28,7 @@
 
 #ifdef WIN32_DLL
 #include <windows.h>
+#include <commctrl.h>
 #define PSAPI_VERSION 1
 #include <psapi.h>  // Must be linked with 'psapi' library
 #define dlsym GetProcAddress
@@ -95,8 +96,101 @@ static PyObject *mpl_tk_blit(PyObject *self, PyObject *args)
     }
 }
 
+#ifdef WIN32_DLL
+LRESULT CALLBACK
+DpiSubclassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam,
+                UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
+{
+    switch (uMsg) {
+    case WM_DPICHANGED:
+        // This function is a subclassed window procedure, and so is run during
+        // the Tcl/Tk event loop. Thus, we must re-take the GIL. Unfortunately,
+        // Tkinter has a *second* lock on Tcl threading that is not exposed
+        // publicly, so we must not call *any* Tk code from here, thus need to
+        // use a polled queue instead.
+        {
+            PyObject *queue = (PyObject *)dwRefData;
+            PyGILState_STATE state = PyGILState_Ensure();
+            PyObject_CallMethod(queue, "put", "i", LOWORD(wParam));
+            PyGILState_Release(state);
+        }
+        return 0;
+    case WM_NCDESTROY:
+        RemoveWindowSubclass(hwnd, DpiSubclassProc, uIdSubclass);
+        break;
+    }
+
+    return DefSubclassProc(hwnd, uMsg, wParam, lParam);
+}
+#endif
+
+static PyObject*
+mpl_tk_enable_dpi_awareness(PyObject* self, PyObject*const* args,
+                            Py_ssize_t nargs)
+{
+    if (nargs != 2) {
+        return PyErr_Format(PyExc_TypeError,
+                            "enable_dpi_awareness() takes 2 positional "
+                            "arguments but %zd were given",
+                            nargs);
+    }
+
+#ifdef WIN32_DLL
+    PyObject* frame = args[0];
+    PyObject* queue = args[1];
+    HWND handle = NULL;
+
+    if (!convert_voidptr(frame, &handle)) {
+        return NULL;
+    }
+
+#ifdef _DPI_AWARENESS_CONTEXTS_
+    HMODULE user32 = LoadLibrary("user32.dll");
+
+    typedef DPI_AWARENESS_CONTEXT (WINAPI *GetWindowDpiAwarenessContext_t)(HWND);
+    GetWindowDpiAwarenessContext_t GetWindowDpiAwarenessContextPtr =
+        (GetWindowDpiAwarenessContext_t)GetProcAddress(
+            user32, "GetWindowDpiAwarenessContext");
+    if (GetWindowDpiAwarenessContextPtr == NULL) {
+        FreeLibrary(user32);
+        Py_RETURN_FALSE;
+    }
+
+    typedef BOOL (WINAPI *AreDpiAwarenessContextsEqual_t)(DPI_AWARENESS_CONTEXT,
+                                                          DPI_AWARENESS_CONTEXT);
+    AreDpiAwarenessContextsEqual_t AreDpiAwarenessContextsEqualPtr =
+        (AreDpiAwarenessContextsEqual_t)GetProcAddress(
+            user32, "AreDpiAwarenessContextsEqual");
+    if (AreDpiAwarenessContextsEqualPtr == NULL) {
+        FreeLibrary(user32);
+        Py_RETURN_FALSE;
+    }
+
+    DPI_AWARENESS_CONTEXT ctx = GetWindowDpiAwarenessContextPtr(handle);
+    bool per_monitor = (
+        AreDpiAwarenessContextsEqualPtr(
+            ctx, DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2) ||
+        AreDpiAwarenessContextsEqualPtr(
+            ctx, DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE));
+
+    if (per_monitor) {
+        // Per monitor aware means we need to handle WM_DPICHANGED by wrapping
+        // the Window Procedure, and the Python side needs to poll to the
+        // queue.
+        SetWindowSubclass(handle, DpiSubclassProc, 0, (DWORD_PTR)queue);
+    }
+    FreeLibrary(user32);
+    return PyBool_FromLong(per_monitor);
+#endif
+#endif
+
+    Py_RETURN_NONE;
+}
+
 static PyMethodDef functions[] = {
     { "blit", (PyCFunction)mpl_tk_blit, METH_VARARGS },
+    { "enable_dpi_awareness", (PyCFunction)mpl_tk_enable_dpi_awareness,
+      METH_FASTCALL },
     { NULL, NULL } /* sentinel */
 };
 
