Merge pull request matplotlib#23363 from anntzer/coop-mi

Simplify FigureCanvas multiple inheritance init by swapping bases order.

Author: timhoffm

lib/matplotlib/backend_bases.py

@@ -1633,6 +1633,7 @@ def __init__(self, figure=None):
         # We don't want to scale up the figure DPI more than once.
         figure._original_dpi = figure.dpi
         self._device_pixel_ratio = 1
+        super().__init__()  # Typically the GUI widget init (if any).
 
     callbacks = property(lambda self: self.figure._canvas_callbacks)
     button_pick_id = property(lambda self: self.figure._button_pick_id)
@@ -1703,14 +1704,20 @@ def pick(self, mouseevent):
     def blit(self, bbox=None):
         """Blit the canvas in bbox (default entire canvas)."""
 
-    @_api.deprecated("3.6", alternative="FigureManagerBase.resize")
     def resize(self, w, h):
         """
         UNUSED: Set the canvas size in pixels.
 
         Certain backends may implement a similar method internally, but this is
         not a requirement of, nor is it used by, Matplotlib itself.
         """
+        # The entire method is actually deprecated, but we allow pass-through
+        # to a parent class to support e.g. QWidget.resize.
+        if hasattr(super(), "resize"):
+            return super().resize(w, h)
+        else:
+            _api.warn_deprecated("3.6", name="resize", obj_type="method",
+                                 alternative="FigureManagerBase.resize")
 
     def draw_event(self, renderer):
         """Pass a `DrawEvent` to all functions connected to ``draw_event``."""

lib/matplotlib/backends/backend_gtk3.py

@@ -68,7 +68,7 @@ def _mpl_to_gtk_cursor(mpl_cursor):
         _backend_gtk.mpl_to_gtk_cursor_name(mpl_cursor))
 
 
-class FigureCanvasGTK3(Gtk.DrawingArea, FigureCanvasBase):
+class FigureCanvasGTK3(FigureCanvasBase, Gtk.DrawingArea):
     required_interactive_framework = "gtk3"
     _timer_cls = TimerGTK3
     manager_class = _api.classproperty(lambda cls: FigureManagerGTK3)
@@ -85,8 +85,7 @@ class FigureCanvasGTK3(Gtk.DrawingArea, FigureCanvasBase):
                   | Gdk.EventMask.SCROLL_MASK)
 
     def __init__(self, figure=None):
-        FigureCanvasBase.__init__(self, figure)
-        GObject.GObject.__init__(self)
+        super().__init__(figure=figure)
 
         self._idle_draw_id = 0
         self._rubberband_rect = None

lib/matplotlib/backends/backend_gtk3agg.py

@@ -7,10 +7,10 @@
 import cairo  # Presence of cairo is already checked by _backend_gtk.
 
 
-class FigureCanvasGTK3Agg(backend_gtk3.FigureCanvasGTK3,
-                          backend_agg.FigureCanvasAgg):
+class FigureCanvasGTK3Agg(backend_agg.FigureCanvasAgg,
+                          backend_gtk3.FigureCanvasGTK3):
     def __init__(self, figure):
-        backend_gtk3.FigureCanvasGTK3.__init__(self, figure)
+        super().__init__(figure=figure)
         self._bbox_queue = []
 
     def on_draw_event(self, widget, ctx):
@@ -63,12 +63,6 @@ def blit(self, bbox=None):
         self._bbox_queue.append(bbox)
         self.queue_draw_area(x, y, width, height)
 
-    def draw(self):
-        # Call these explicitly because GTK's draw is a GObject method which
-        # isn't cooperative with Python class methods.
-        backend_agg.FigureCanvasAgg.draw(self)
-        backend_gtk3.FigureCanvasGTK3.draw(self)
-
 
 @_api.deprecated("3.6", alternative="backend_gtk3.FigureManagerGTK3")
 class FigureManagerGTK3Agg(backend_gtk3.FigureManagerGTK3):

lib/matplotlib/backends/backend_gtk3cairo.py

@@ -11,8 +11,8 @@ def set_context(self, ctx):
         self.gc.ctx = backend_cairo._to_context(ctx)
 
 
-class FigureCanvasGTK3Cairo(backend_gtk3.FigureCanvasGTK3,
-                            backend_cairo.FigureCanvasCairo):
+class FigureCanvasGTK3Cairo(backend_cairo.FigureCanvasCairo,
+                            backend_gtk3.FigureCanvasGTK3):
 
     def on_draw_event(self, widget, ctx):
         with (self.toolbar._wait_cursor_for_draw_cm() if self.toolbar

lib/matplotlib/backends/backend_gtk4.py

@@ -29,16 +29,16 @@
 from ._backend_gtk import backend_version  # noqa: F401 # pylint: disable=W0611
 
 
-class FigureCanvasGTK4(Gtk.DrawingArea, FigureCanvasBase):
+class FigureCanvasGTK4(FigureCanvasBase, Gtk.DrawingArea):
     required_interactive_framework = "gtk4"
     supports_blit = False
     _timer_cls = TimerGTK4
     manager_class = _api.classproperty(lambda cls: FigureManagerGTK4)
     _context_is_scaled = False
 
     def __init__(self, figure=None):
-        FigureCanvasBase.__init__(self, figure)
-        GObject.GObject.__init__(self)
+        super().__init__(figure=figure)
+
         self.set_hexpand(True)
         self.set_vexpand(True)
 

lib/matplotlib/backends/backend_gtk4agg.py

@@ -7,10 +7,8 @@
 import cairo  # Presence of cairo is already checked by _backend_gtk.
 
 
-class FigureCanvasGTK4Agg(backend_gtk4.FigureCanvasGTK4,
-                          backend_agg.FigureCanvasAgg):
-    def __init__(self, figure):
-        backend_gtk4.FigureCanvasGTK4.__init__(self, figure)
+class FigureCanvasGTK4Agg(backend_agg.FigureCanvasAgg,
+                          backend_gtk4.FigureCanvasGTK4):
 
     def on_draw_event(self, widget, ctx):
         scale = self.device_pixel_ratio
@@ -32,12 +30,6 @@ def on_draw_event(self, widget, ctx):
 
         return False
 
-    def draw(self):
-        # Call these explicitly because GTK's draw is a GObject method which
-        # isn't cooperative with Python class methods.
-        backend_agg.FigureCanvasAgg.draw(self)
-        backend_gtk4.FigureCanvasGTK4.draw(self)
-
 
 @_api.deprecated("3.6", alternative="backend_gtk4.FigureManagerGTK4")
 class FigureManagerGTK4Agg(backend_gtk4.FigureManagerGTK4):

lib/matplotlib/backends/backend_gtk4cairo.py

@@ -11,8 +11,8 @@ def set_context(self, ctx):
         self.gc.ctx = backend_cairo._to_context(ctx)
 
 
-class FigureCanvasGTK4Cairo(backend_gtk4.FigureCanvasGTK4,
-                            backend_cairo.FigureCanvasCairo):
+class FigureCanvasGTK4Cairo(backend_cairo.FigureCanvasCairo,
+                            backend_gtk4.FigureCanvasGTK4):
     _context_is_scaled = True
 
     def on_draw_event(self, widget, ctx):

lib/matplotlib/backends/backend_macosx.py

@@ -17,9 +17,17 @@ class TimerMac(_macosx.Timer, TimerBase):
     # completely implemented at the C-level (in _macosx.Timer)
 
 
-class FigureCanvasMac(_macosx.FigureCanvas, FigureCanvasAgg):
+class FigureCanvasMac(FigureCanvasAgg, _macosx.FigureCanvas, FigureCanvasBase):
     # docstring inherited
 
+    # Ideally this class would be `class FCMacAgg(FCAgg, FCMac)`
+    # (FC=FigureCanvas) where FCMac would be an ObjC-implemented mac-specific
+    # class also inheriting from FCBase (this is the approach with other GUI
+    # toolkits).  However, writing an extension type inheriting from a Python
+    # base class is slightly tricky (the extension type must be a heap type),
+    # and we can just as well lift the FCBase base up one level, keeping it *at
+    # the end* to have the right method resolution order.
+
     # Events such as button presses, mouse movements, and key presses
     # are handled in the C code and the base class methods
     # button_press_event, button_release_event, motion_notify_event,
@@ -30,9 +38,7 @@ class FigureCanvasMac(_macosx.FigureCanvas, FigureCanvasAgg):
     manager_class = _api.classproperty(lambda cls: FigureManagerMac)
 
     def __init__(self, figure):
-        FigureCanvasBase.__init__(self, figure)
-        width, height = self.get_width_height()
-        _macosx.FigureCanvas.__init__(self, width, height)
+        super().__init__(figure=figure)
         self._draw_pending = False
         self._is_drawing = False
 

lib/matplotlib/backends/backend_qt.py

@@ -160,46 +160,6 @@ def _create_qApp():
     return app
 
 
-def _allow_super_init(__init__):
-    """
-    Decorator for ``__init__`` to allow ``super().__init__`` on PySide2.
-    """
-
-    if QT_API in ["PyQt5", "PyQt6"]:
-
-        return __init__
-
-    else:
-        # To work around lack of cooperative inheritance in PySide2 and
-        # PySide6, 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 or sip, or PySide{,2,6}
-        # or Shiboken packages), and manually call its `__init__`, once again
-        # passing the additional arguments.
-
-        qwidget_init = QtWidgets.QWidget.__init__
-
-        def cooperative_qwidget_init(self, *args, **kwargs):
-            qwidget_init(self)
-            mro = type(self).__mro__
-            next_coop_init = next(
-                cls for cls in mro[mro.index(QtWidgets.QWidget) + 1:]
-                if cls.__module__.split(".")[0] not in [
-                    "PySide2", "PySide6", "Shiboken",
-                ])
-            next_coop_init.__init__(self, *args, **kwargs)
-
-        @functools.wraps(__init__)
-        def wrapper(self, *args, **kwargs):
-            with cbook._setattr_cm(QtWidgets.QWidget,
-                                   __init__=cooperative_qwidget_init):
-                __init__(self, *args, **kwargs)
-
-        return wrapper
-
-
 class TimerQT(TimerBase):
     """Subclass of `.TimerBase` using QTimer events."""
 
@@ -229,7 +189,7 @@ def _timer_stop(self):
         self._timer.stop()
 
 
-class FigureCanvasQT(QtWidgets.QWidget, FigureCanvasBase):
+class FigureCanvasQT(FigureCanvasBase, QtWidgets.QWidget):
     required_interactive_framework = "qt"
     _timer_cls = TimerQT
     manager_class = _api.classproperty(lambda cls: FigureManagerQT)
@@ -244,7 +204,6 @@ class FigureCanvasQT(QtWidgets.QWidget, FigureCanvasBase):
         ]
     }
 
-    @_allow_super_init
     def __init__(self, figure=None):
         _create_qApp()
         super().__init__(figure=figure)

lib/matplotlib/backends/backend_qtagg.py

@@ -16,10 +16,6 @@
 
 class FigureCanvasQTAgg(FigureCanvasAgg, FigureCanvasQT):
 
-    def __init__(self, figure=None):
-        # Must pass 'figure' as kwarg to Qt base class.
-        super().__init__(figure=figure)
-
     def paintEvent(self, event):
         """
         Copy the image from the Agg canvas to the qt.drawable.