Simplify FigureCanvas multiple inheritance init by swapping bases order.

Instead of having e.g. FigureCanvasQT inherit from QWidget and then
FigureCanvasBase, which requires workarounds to handle the fact that
PySide.QWidget does not participate in cooperative multiple inheritance
(we work around that with _allow_super_init in qt, and manual super
calls in other toolkits), just swap the order of bases to
(FigureCanvasBase, QWidget) and make sure that FigureCanvasBase *does*
participate in cooperative multiple inheritance.

Also note the changes in FigureCanvasGTK{3,4}Agg.draw, where the new
inheritance order also makes more sense.

Author: anntzer

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.