@@ -192,10 +192,11 @@ def __init__(self, figure):
         # http://pyqt.sourceforge.net/Docs/PyQt5/pyqt4_differences.html#cooperative-multi-inheritance
         super(FigureCanvasQT, self).__init__(figure=figure)
         self.figure = figure
+        self._draw_pending = False
+        self._draw_rect_callback = lambda painter: None
+        self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent)
         self.setMouseTracking(True)
-        w, h = self.get_width_height()
-        self.resize(w, h)
-
+        self.resize(*self.get_width_height())
         # Key auto-repeat enabled by default
         self._keyautorepeat = True
 
@@ -381,6 +382,53 @@ def stop_event_loop(self, event=None):
         if hasattr(self, "_event_loop"):
             self._event_loop.quit()
 
+    def draw(self):
+        """Render the figure, and queue a request for a Qt draw.
+        """
+        # The Agg draw is done here; delaying causes problems with code that
+        # uses the result of the draw() to update plot elements.
+        super(FigureCanvasQT, self).draw()
+        self.update()
+
+    def draw_idle(self):
+        """Queue redraw of the Agg buffer and request Qt paintEvent.
+        """
+        # The Agg draw needs to be handled by the same thread matplotlib
+        # modifies the scene graph from. Post Agg draw request to the
+        # current event loop in order to ensure thread affinity and to
+        # accumulate multiple draw requests from event handling.
+        # TODO: queued signal connection might be safer than singleShot
+        if not self._draw_pending:
+            self._draw_pending = True
+            QtCore.QTimer.singleShot(0, self._draw_idle)
+
+    def _draw_idle(self):
+        if self.height() < 0 or self.width() < 0:
+            self._draw_pending = False
+            return
+        try:
+            self.draw()
+        except Exception:
+            # Uncaught exceptions are fatal for PyQt5, so catch them instead.
+            traceback.print_exc()
+        finally:
+            self._draw_pending = False
+
+    def drawRectangle(self, rect):
+        # Draw the zoom rectangle to the QPainter.  _draw_rect_callback needs
+        # to be called at the end of paintEvent.
+        if rect is not None:
+            def _draw_rect_callback(painter):
+                pen = QtGui.QPen(QtCore.Qt.black, 1 / self._dpi_ratio,
+                                 QtCore.Qt.DotLine)
+                painter.setPen(pen)
+                painter.drawRect(*(pt / self._dpi_ratio for pt in rect))
+        else:
+            def _draw_rect_callback(painter):
+                return
+        self._draw_rect_callback = _draw_rect_callback
+        self.update()
+
 
 class MainWindow(QtWidgets.QMainWindow):
     closing = QtCore.Signal()
 
@@ -32,17 +32,7 @@ class FigureCanvasQTAggBase(FigureCanvasAgg):
 
     def __init__(self, figure):
         super(FigureCanvasQTAggBase, self).__init__(figure=figure)
-        self.setAttribute(QtCore.Qt.WA_OpaquePaintEvent)
-        self._agg_draw_pending = False
         self._bbox_queue = []
-        self._drawRect = None
-
-    def drawRectangle(self, rect):
-        if rect is not None:
-            self._drawRect = [pt / self._dpi_ratio for pt in rect]
-        else:
-            self._drawRect = None
-        self.update()
 
     def paintEvent(self, e):
         """Copy the image from the Agg canvas to the qt.drawable.
@@ -77,49 +67,10 @@ def paintEvent(self, e):
             if QT_API == 'PySide' and six.PY3:
                 ctypes.c_long.from_address(id(buf)).value = 1
 
-        # draw the zoom rectangle to the QPainter
-        if self._drawRect is not None:
-            pen = QtGui.QPen(QtCore.Qt.black, 1 / self._dpi_ratio,
-                             QtCore.Qt.DotLine)
-            painter.setPen(pen)
-            x, y, w, h = self._drawRect
-            painter.drawRect(x, y, w, h)
+        self._draw_rect_callback(painter)
 
         painter.end()
 
-    def draw(self):
-        """Draw the figure with Agg, and queue a request for a Qt draw.
-        """
-        # The Agg draw is done here; delaying causes problems with code that
-        # uses the result of the draw() to update plot elements.
-        super(FigureCanvasQTAggBase, self).draw()
-        self.update()
-
-    def draw_idle(self):
-        """Queue redraw of the Agg buffer and request Qt paintEvent.
-        """
-        # The Agg draw needs to be handled by the same thread matplotlib
-        # modifies the scene graph from. Post Agg draw request to the
-        # current event loop in order to ensure thread affinity and to
-        # accumulate multiple draw requests from event handling.
-        # TODO: queued signal connection might be safer than singleShot
-        if not self._agg_draw_pending:
-            self._agg_draw_pending = True
-            QtCore.QTimer.singleShot(0, self.__draw_idle_agg)
-
-    def __draw_idle_agg(self, *args):
-        if self.height() < 0 or self.width() < 0:
-            self._agg_draw_pending = False
-            return
-        try:
-            super(FigureCanvasQTAggBase, self).draw()
-            self.update()
-        except Exception:
-            # Uncaught exceptions are fatal for PyQt5, so catch them instead.
-            traceback.print_exc()
-        finally:
-            self._agg_draw_pending = False
-
     def blit(self, bbox=None):
         """Blit the region in bbox.
         """
 
@@ -0,0 +1,32 @@
+import cairocffi as cairo
+
+from .backend_cairo import RendererCairo
+from .backend_qt5 import (
+    QtCore, QtGui, _BackendQT5, FigureCanvasQT, FigureManagerQT,
+    NavigationToolbar2QT)
+
+
+class FigureCanvasQTCairo(FigureCanvasQT):
+    def __init__(self, figure):
+        super(FigureCanvasQTCairo, self).__init__(figure=figure)
+        self._renderer = RendererCairo(self.figure.dpi)
+
+    def paintEvent(self, event):
+        width = self.width()
+        height = self.height()
+        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
+        self._renderer.set_ctx_from_surface(surface)
+        # This should be really done by set_ctx_from_surface...
+        self._renderer.set_width_height(width, height)
+        self.figure.draw(self._renderer)
+        qimage = QtGui.QImage(surface.get_data(), width, height,
+                              QtGui.QImage.Format_ARGB32_Premultiplied)
+        painter = QtGui.QPainter(self)
+        painter.drawImage(QtCore.QPoint(0, 0), qimage)
+        self._draw_rect_callback(painter)
+        painter.end()
+
+
+@_BackendQT5.export
+class _BackendQT5Cairo(_BackendQT5):
+    FigureCanvas = FigureCanvasQTCairo
@@ -39,7 +39,7 @@
 # change for later versions.
 
 interactive_bk = ['GTK', 'GTKAgg', 'GTKCairo', 'MacOSX',
-                  'Qt4Agg', 'Qt5Agg', 'TkAgg', 'WX', 'WXAgg',
+                  'Qt4Agg', 'Qt5Agg', 'Qt5Cairo', 'TkAgg', 'WX', 'WXAgg',
                   'GTK3Cairo', 'GTK3Agg', 'WebAgg', 'nbAgg']
 
 
 
@@ -29,6 +29,7 @@ def _get_testable_interactive_backends():
                 backend)
         for module_name, backend in [
                 ("PyQt5", "qt5agg"),
+                ("PyQt5", "qt5cairo"),
                 ("tkinter", "tkagg"),
                 ("wx", "wxagg")]]