Add "experimental" support for PyQt6/PySide6.

anntzer · anntzer · commit 46dbac25adb1 · 2021-01-07T17:51:29.000+01:00
Currently these must be selected via `QT_API=pyqt6`/`QT_API=pyside6`.

Note that I didn't create a separate backend_qt6agg (and
backend_qt6cairo, and mplcairo.qt6...) as it seems preferable to instead
move towards a single backend_qtagg and allow selection of the actual qt
binding via the orthogonal QT_API mechanism.

Most of the work is just handling attributes that moved out of the Qt
namespace (but the new locations are also compatible with Qt5).

PyQt6 mouse interactions are currently broken because its version of
QMouseEvent doesn't have an `x()` method.  I assume that's just an
oversight (the method still exists at the C level) and will be fixed in
a future bugfix, so we should at least wait a bit for that.
diff --git a/lib/matplotlib/backends/backend_qt5.py b/lib/matplotlib/backends/backend_qt5.py
@@ -15,70 +15,76 @@
 from matplotlib.backends.qt_editor._formsubplottool import UiSubplotTool
 from . import qt_compat
 from .qt_compat import (
-    QtCore, QtGui, QtWidgets, __version__, QT_API,
+    QtCore, QtGui, QtWidgets, Qt, __version__, QT_API,
     _devicePixelRatioF, _isdeleted, _setDevicePixelRatio,
 )
 
 backend_version = __version__
 
+# Foos = QFlags<Foo> are exported as Qt.Foos on PyQt6 but Qt.Foo on PyQt5, so
+# we just hard-code numeric values for simplicity.
+
 # SPECIAL_KEYS are keys that do *not* return their unicode name
 # instead they have manually specified names
-SPECIAL_KEYS = {QtCore.Qt.Key_Control: 'control',
-                QtCore.Qt.Key_Shift: 'shift',
-                QtCore.Qt.Key_Alt: 'alt',
-                QtCore.Qt.Key_Meta: 'super',
-                QtCore.Qt.Key_Return: 'enter',
-                QtCore.Qt.Key_Left: 'left',
-                QtCore.Qt.Key_Up: 'up',
-                QtCore.Qt.Key_Right: 'right',
-                QtCore.Qt.Key_Down: 'down',
-                QtCore.Qt.Key_Escape: 'escape',
-                QtCore.Qt.Key_F1: 'f1',
-                QtCore.Qt.Key_F2: 'f2',
-                QtCore.Qt.Key_F3: 'f3',
-                QtCore.Qt.Key_F4: 'f4',
-                QtCore.Qt.Key_F5: 'f5',
-                QtCore.Qt.Key_F6: 'f6',
-                QtCore.Qt.Key_F7: 'f7',
-                QtCore.Qt.Key_F8: 'f8',
-                QtCore.Qt.Key_F9: 'f9',
-                QtCore.Qt.Key_F10: 'f10',
-                QtCore.Qt.Key_F11: 'f11',
-                QtCore.Qt.Key_F12: 'f12',
-                QtCore.Qt.Key_Home: 'home',
-                QtCore.Qt.Key_End: 'end',
-                QtCore.Qt.Key_PageUp: 'pageup',
-                QtCore.Qt.Key_PageDown: 'pagedown',
-                QtCore.Qt.Key_Tab: 'tab',
-                QtCore.Qt.Key_Backspace: 'backspace',
-                QtCore.Qt.Key_Enter: 'enter',
-                QtCore.Qt.Key_Insert: 'insert',
-                QtCore.Qt.Key_Delete: 'delete',
-                QtCore.Qt.Key_Pause: 'pause',
-                QtCore.Qt.Key_SysReq: 'sysreq',
-                QtCore.Qt.Key_Clear: 'clear', }
+SPECIAL_KEYS = {
+    Qt.Key.Key_Control: 'control',
+    Qt.Key.Key_Shift: 'shift',
+    Qt.Key.Key_Alt: 'alt',
+    Qt.Key.Key_Meta: 'super',
+    Qt.Key.Key_Return: 'enter',
+    Qt.Key.Key_Left: 'left',
+    Qt.Key.Key_Up: 'up',
+    Qt.Key.Key_Right: 'right',
+    Qt.Key.Key_Down: 'down',
+    Qt.Key.Key_Escape: 'escape',
+    Qt.Key.Key_F1: 'f1',
+    Qt.Key.Key_F2: 'f2',
+    Qt.Key.Key_F3: 'f3',
+    Qt.Key.Key_F4: 'f4',
+    Qt.Key.Key_F5: 'f5',
+    Qt.Key.Key_F6: 'f6',
+    Qt.Key.Key_F7: 'f7',
+    Qt.Key.Key_F8: 'f8',
+    Qt.Key.Key_F9: 'f9',
+    Qt.Key.Key_F10: 'f10',
+    Qt.Key.Key_F11: 'f11',
+    Qt.Key.Key_F12: 'f12',
+    Qt.Key.Key_Home: 'home',
+    Qt.Key.Key_End: 'end',
+    Qt.Key.Key_PageUp: 'pageup',
+    Qt.Key.Key_PageDown: 'pagedown',
+    Qt.Key.Key_Tab: 'tab',
+    Qt.Key.Key_Backspace: 'backspace',
+    Qt.Key.Key_Enter: 'enter',
+    Qt.Key.Key_Insert: 'insert',
+    Qt.Key.Key_Delete: 'delete',
+    Qt.Key.Key_Pause: 'pause',
+    Qt.Key.Key_SysReq: 'sysreq',
+    Qt.Key.Key_Clear: 'clear',
+}
 if sys.platform == 'darwin':
     # in OSX, the control and super (aka cmd/apple) keys are switched, so
     # switch them back.
-    SPECIAL_KEYS.update({QtCore.Qt.Key_Control: 'cmd',  # cmd/apple key
-                         QtCore.Qt.Key_Meta: 'control',
-                         })
+    SPECIAL_KEYS.update({
+        Qt.Key.Key_Control: 'cmd',  # cmd/apple key
+        Qt.Key.Key_Meta: 'control',
+    })
 # Define which modifier keys are collected on keyboard events.
-# Elements are (Modifier Flag, Qt Key) tuples.
+# Elements are (Qt::KeyboardModifier(s), Qt Key) tuples.
 # Order determines the modifier order (ctrl+alt+...) reported by Matplotlib.
 _MODIFIER_KEYS = [
-    (QtCore.Qt.ShiftModifier, QtCore.Qt.Key_Shift),
-    (QtCore.Qt.ControlModifier, QtCore.Qt.Key_Control),
-    (QtCore.Qt.AltModifier, QtCore.Qt.Key_Alt),
-    (QtCore.Qt.MetaModifier, QtCore.Qt.Key_Meta),
+    (0x02000000, Qt.Key.Key_Shift),
+    (0x04000000, Qt.Key.Key_Control),
+    (0x08000000, Qt.Key.Key_Alt),
+    (0x10000000, Qt.Key.Key_Meta),
 ]
 cursord = {
-    cursors.MOVE: QtCore.Qt.SizeAllCursor,
-    cursors.HAND: QtCore.Qt.PointingHandCursor,
-    cursors.POINTER: QtCore.Qt.ArrowCursor,
-    cursors.SELECT_REGION: QtCore.Qt.CrossCursor,
-    cursors.WAIT: QtCore.Qt.WaitCursor,
-    }
+    cursors.MOVE: Qt.CursorShape.SizeAllCursor,
+    cursors.HAND: Qt.CursorShape.PointingHandCursor,
+    cursors.POINTER: Qt.CursorShape.ArrowCursor,
+    cursors.SELECT_REGION: Qt.CursorShape.CrossCursor,
+    cursors.WAIT: Qt.CursorShape.WaitCursor,
+}
 SUPER = 0  # Deprecated.
 ALT = 1  # Deprecated.
 CTRL = 2  # Deprecated.
@@ -87,6 +93,10 @@
     (SPECIAL_KEYS[key], mod, key) for mod, key in _MODIFIER_KEYS]
 
 
+def _to_int(x):
+    return x.value if QT_API == "PyQt6" else int(x)
+
+
 # make place holder
 qApp = None
 
@@ -140,17 +150,17 @@ def _allow_super_init(__init__):
     Decorator for ``__init__`` to allow ``super().__init__`` on PyQt4/PySide2.
     """
 
-    if QT_API == "PyQt5":
+    if QT_API in ["PyQt5", "PyQt6"]:
 
         return __init__
 
     else:
-        # To work around lack of cooperative inheritance in PyQt4, PySide,
-        # and PySide2, when calling FigureCanvasQT.__init__, we temporarily
+        # To work around lack of cooperative inheritance in PyQt4 and
+        # PySide{,2,6}, when calling FigureCanvasQT.__init__, we temporarily
         # patch QWidget.__init__ by a cooperative version, that first calls
         # QWidget.__init__ with no additional arguments, and then finds the
         # next class in the MRO with an __init__ that does support cooperative
-        # inheritance (i.e., not defined by the PyQt4, PySide, PySide2, sip
+        # inheritance (i.e., not defined by the PyQt4 or sip, or PySide{,2,6}
         # or Shiboken packages), and manually call its `__init__`, once again
         # passing the additional arguments.
 
@@ -162,7 +172,9 @@ def cooperative_qwidget_init(self, *args, **kwargs):
             next_coop_init = next(
                 cls for cls in mro[mro.index(QtWidgets.QWidget) + 1:]
                 if cls.__module__.split(".")[0] not in [
-                    "PyQt4", "sip", "PySide", "PySide2", "Shiboken"])
+                    "PyQt4", "sip",
+                    "PySide", "PySide2", "PySide6", "Shiboken",
+                ])
             next_coop_init.__init__(self, *args, **kwargs)
 
         @functools.wraps(__init__)
@@ -207,13 +219,13 @@ class FigureCanvasQT(QtWidgets.QWidget, FigureCanvasBase):
     required_interactive_framework = "qt5"
     _timer_cls = TimerQT
 
-    # map Qt button codes to MouseEvent's ones:
-    buttond = {QtCore.Qt.LeftButton: MouseButton.LEFT,
-               QtCore.Qt.MidButton: MouseButton.MIDDLE,
-               QtCore.Qt.RightButton: MouseButton.RIGHT,
-               QtCore.Qt.XButton1: MouseButton.BACK,
-               QtCore.Qt.XButton2: MouseButton.FORWARD,
-               }
+    buttond = {  # Map Qt::MouseButton(s) to MouseEvents.
+        0x01: MouseButton.LEFT,
+        0x02: MouseButton.RIGHT,
+        0x04: MouseButton.MIDDLE,
+        0x08: MouseButton.BACK,
+        0x10: MouseButton.FORWARD,
+    }
 
     @_allow_super_init
     def __init__(self, figure):
@@ -233,11 +245,11 @@ def __init__(self, figure):
         self._is_drawing = False
         self._draw_rect_callback = lambda painter: None
 
-        self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent)
+        self.setAttribute(Qt.WidgetAttribute.WA_OpaquePaintEvent)
         self.setMouseTracking(True)
         self.resize(*self.get_width_height())
 
-        palette = QtGui.QPalette(QtCore.Qt.white)
+        palette = QtGui.QPalette(QtGui.QColor("white"))
         self.setPalette(palette)
 
     def _update_figure_dpi(self):
@@ -311,14 +323,14 @@ def mouseEventCoords(self, pos):
 
     def mousePressEvent(self, event):
         x, y = self.mouseEventCoords(event.pos())
-        button = self.buttond.get(event.button())
+        button = self.buttond.get(_to_int(event.button()))
         if button is not None:
             FigureCanvasBase.button_press_event(self, x, y, button,
                                                 guiEvent=event)
 
     def mouseDoubleClickEvent(self, event):
         x, y = self.mouseEventCoords(event.pos())
-        button = self.buttond.get(event.button())
+        button = self.buttond.get(_to_int(event.button()))
         if button is not None:
             FigureCanvasBase.button_press_event(self, x, y,
                                                 button, dblclick=True,
@@ -330,7 +342,7 @@ def mouseMoveEvent(self, event):
 
     def mouseReleaseEvent(self, event):
         x, y = self.mouseEventCoords(event)
-        button = self.buttond.get(event.button())
+        button = self.buttond.get(_to_int(event.button()))
         if button is not None:
             FigureCanvasBase.button_release_event(self, x, y, button,
                                                   guiEvent=event)
@@ -368,6 +380,9 @@ def keyReleaseEvent(self, event):
             FigureCanvasBase.key_release_event(self, key, guiEvent=event)
 
     def resizeEvent(self, event):
+        frame = sys._getframe()
+        if frame.f_code is frame.f_back.f_code:  # Prevent PyQt6 recursion.
+            return
         w = event.size().width() * self._dpi_ratio
         h = event.size().height() * self._dpi_ratio
         dpival = self.figure.dpi
@@ -388,7 +403,7 @@ def minumumSizeHint(self):
 
     def _get_key(self, event):
         event_key = event.key()
-        event_mods = int(event.modifiers())  # actually a bitmask
+        event_mods = _to_int(event.modifiers())  # actually a bitmask
 
         # get names of the pressed modifier keys
         # 'control' is named 'control' when a standalone key, but 'ctrl' when a
@@ -433,7 +448,7 @@ def start_event_loop(self, timeout=0):
         if timeout > 0:
             timer = QtCore.QTimer.singleShot(int(timeout * 1000),
                                              event_loop.quit)
-        event_loop.exec_()
+        event_loop.exec()
 
     def stop_event_loop(self, event=None):
         # docstring inherited
@@ -575,7 +590,7 @@ def __init__(self, canvas, num):
         # StrongFocus accepts both tab and click to focus and will enable the
         # canvas to process event without clicking.
         # https://doc.qt.io/qt-5/qt.html#FocusPolicy-enum
-        self.canvas.setFocusPolicy(QtCore.Qt.StrongFocus)
+        self.canvas.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
         self.canvas.setFocus()
 
         self.window.raise_()
@@ -654,8 +669,8 @@ class NavigationToolbar2QT(NavigationToolbar2, QtWidgets.QToolBar):
     def __init__(self, canvas, parent, coordinates=True):
         """coordinates: should we show the coordinates on the right?"""
         QtWidgets.QToolBar.__init__(self, parent)
-        self.setAllowedAreas(
-            QtCore.Qt.TopToolBarArea | QtCore.Qt.BottomToolBarArea)
+        self.setAllowedAreas(  # Qt::TopToolBarArea | Qt::BottomToolBarArea
+            Qt.ToolBarAreas(0x4 | 0x8))
 
         self.coordinates = coordinates
         self._actions = {}  # mapping of toolitem method names to QActions.
@@ -677,11 +692,11 @@ def __init__(self, canvas, parent, coordinates=True):
         # will resize this label instead of the buttons.
         if self.coordinates:
             self.locLabel = QtWidgets.QLabel("", self)
-            self.locLabel.setAlignment(
-                QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
+            self.locLabel.setAlignment(  # Qt::AlignRight | Qt::AlignVCenter
+                Qt.Alignment(0x02 | 0x80))
             self.locLabel.setSizePolicy(
-                QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding,
-                                      QtWidgets.QSizePolicy.Ignored))
+                QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding,
+                                      QtWidgets.QSizePolicy.Policy.Ignored))
             labelAction = self.addWidget(self.locLabel)
             labelAction.setVisible(True)
 
@@ -715,7 +730,7 @@ def _icon(self, name):
         if self.palette().color(self.backgroundRole()).value() < 128:
             icon_color = self.palette().color(self.foregroundRole())
             mask = pm.createMaskFromColor(QtGui.QColor('black'),
-                                          QtCore.Qt.MaskOutColor)
+                                          Qt.MaskMode.MaskOutColor)
             pm.fill(icon_color)
             pm.setMask(mask)
         return QtGui.QIcon(pm)
@@ -785,7 +800,7 @@ def configure_subplots(self):
         image = str(cbook._get_data_path('images/matplotlib.png'))
         dia = SubplotToolQt(self.canvas.figure, self.canvas.parent())
         dia.setWindowIcon(QtGui.QIcon(image))
-        dia.exec_()
+        dia.exec()
 
     def save_figure(self, *args):
         filetypes = self.canvas.get_supported_filetypes_grouped()
@@ -874,7 +889,7 @@ def _export_values(self):
             QtGui.QFontMetrics(text.document().defaultFont())
             .size(0, text.toPlainText()).height() + 20)
         text.setMaximumSize(size)
-        dialog.exec_()
+        dialog.exec()
 
     def _on_value_changed(self):
         self._figure.subplots_adjust(**{attr: self._widgets[attr].value()
@@ -899,14 +914,14 @@ class ToolbarQt(ToolContainerBase, QtWidgets.QToolBar):
     def __init__(self, toolmanager, parent):
         ToolContainerBase.__init__(self, toolmanager)
         QtWidgets.QToolBar.__init__(self, parent)
-        self.setAllowedAreas(
-            QtCore.Qt.TopToolBarArea | QtCore.Qt.BottomToolBarArea)
+        self.setAllowedAreas(  # Qt::TopToolBarArea | Qt::BottomToolBarArea
+            Qt.ToolBarAreas(0x4 | 0x8))
         message_label = QtWidgets.QLabel("")
-        message_label.setAlignment(
-            QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
+        message_label.setAlignment(  # Qt::AlignRight | Qt::AlignVCenter
+            Qt.Alignment(0x02 | 0x80))
         message_label.setSizePolicy(
-            QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding,
-                                  QtWidgets.QSizePolicy.Ignored))
+            QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Policy.Expanding,
+                                  QtWidgets.QSizePolicy.Policy.Ignored))
         self._message_action = self.addWidget(message_label)
         self._toolitems = {}
         self._groups = {}
@@ -1031,7 +1046,7 @@ def mainloop():
         if is_python_signal_handler:
             signal.signal(signal.SIGINT, signal.SIG_DFL)
         try:
-            qApp.exec_()
+            qApp.exec()
         finally:
             # reset the SIGINT exception handler
             if is_python_signal_handler:
diff --git a/lib/matplotlib/backends/backend_qt5agg.py b/lib/matplotlib/backends/backend_qt5agg.py
@@ -59,14 +59,20 @@ def paintEvent(self, event):
             # clear the widget canvas
             painter.eraseRect(rect)
 
-            qimage = QtGui.QImage(buf, buf.shape[1], buf.shape[0],
-                                  QtGui.QImage.Format_ARGB32_Premultiplied)
+            if QT_API == "PyQt6":
+                import sip
+                buf_ptr = sip.voidptr(buf)
+            else:
+                buf_ptr = buf
+            qimage = QtGui.QImage(
+                buf_ptr, buf.shape[1], buf.shape[0],
+                QtGui.QImage.Format.Format_ARGB32_Premultiplied)
             _setDevicePixelRatio(qimage, self._dpi_ratio)
             # set origin using original QT coordinates
             origin = QtCore.QPoint(rect.left(), rect.top())
             painter.drawImage(origin, qimage)
             # Adjust the buf reference count to work around a memory
-            # leak bug in QImage under PySide on Python 3.
+            # leak bug in QImage under PySide.
             if QT_API in ('PySide', 'PySide2'):
                 ctypes.c_long.from_address(id(buf)).value = 1
 
diff --git a/lib/matplotlib/backends/backend_qt5cairo.py b/lib/matplotlib/backends/backend_qt5cairo.py
@@ -26,11 +26,16 @@ def paintEvent(self, event):
             self._renderer.set_width_height(width, height)
             self.figure.draw(self._renderer)
         buf = self._renderer.gc.ctx.get_target().get_data()
-        qimage = QtGui.QImage(buf, width, height,
-                              QtGui.QImage.Format_ARGB32_Premultiplied)
+        if QT_API == "PyQt6":
+            import sip
+            buf_ptr = sip.voidptr(buf)
+        else:
+            buf_ptr = buf
+        qimage = QtGui.QImage(buf_ptr, width, height,
+                              QtGui.QImage.Format.Format_ARGB32_Premultiplied)
         # Adjust the buf reference count to work around a memory leak bug in
-        # QImage under PySide on Python 3.
-        if QT_API == 'PySide':
+        # QImage under PySide.
+        if QT_API in ('PySide', 'PySide2'):
             ctypes.c_long.from_address(id(buf)).value = 1
         _setDevicePixelRatio(qimage, dpi_ratio)
         painter = QtGui.QPainter(self)
diff --git a/lib/matplotlib/backends/qt_compat.py b/lib/matplotlib/backends/qt_compat.py
