Rewrite blocking_input to something much simpler.

The new implementation is ~200 lines shorter, does not require
subclassing (and tracking parent methods when trying to understand the
implementation), and keeps all the logic at the place of use instead of
it being in blocking_input.py (which is now deprecated).

Author: anntzer

doc/api/next_api_changes/deprecations/20208-AL.rst

@@ -0,0 +1,4 @@
+``matplotlib.blocking_input``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+This module has been deprecated.  Instead, use ``canvas.start_event_loop()``
+and ``canvas.stop_event_loop()`` while connecting event callbacks as needed.

lib/matplotlib/_blocking_input.py

@@ -0,0 +1,30 @@
+def blocking_input_loop(figure, event_names, timeout, handler):
+    """
+    Run *figure*'s event loop while listening to interactive events.
+
+    The events listed in *event_names* are passed to *handler*.
+
+    This function is used to implement `.Figure.waitforbuttonpress`,
+    `.Figure.ginput`, and `.Axes.clabel`.
+
+    Parameters
+    ----------
+    figure : `~matplotlib.figure.Figure`
+    event_names : list of str
+        The names of the events passed to *handler*.
+    timeout : float
+        If positive, the event loop is stopped after *timeout* seconds.
+    handler : Callable[[Event], Any]
+        Function called for each event; it can force an early exit of the event
+        loop by calling ``canvas.stop_event_loop()``.
+    """
+    if hasattr(figure.canvas, "manager"):
+        figure.show()  # Ensure that the figure is shown if we are managing it.
+    # Connect the events to the on_event function call.
+    cids = [figure.canvas.mpl_connect(name, handler) for name in event_names]
+    try:
+        figure.canvas.start_event_loop(timeout)  # Start event loop.
+    finally:  # Run even on exception like ctrl-c.
+        # Disconnect the callbacks.
+        for cid in cids:
+            figure.canvas.mpl_disconnect(cid)

lib/matplotlib/blocking_input.py

@@ -26,6 +26,7 @@
 from matplotlib.backend_bases import MouseButton
 import matplotlib.lines as mlines
 
+_api.warn_deprecated("3.5", name=__name__, obj_type="module")
 _log = logging.getLogger(__name__)
 
 

lib/matplotlib/contour.py

@@ -2,13 +2,15 @@
 Classes to support contour plotting and labelling for the Axes class.
 """
 
+import functools
 from numbers import Integral
 
 import numpy as np
 from numpy import ma
 
 import matplotlib as mpl
-from matplotlib import _api
+from matplotlib import _api, docstring
+from matplotlib.backend_bases import MouseButton
 import matplotlib.path as mpath
 import matplotlib.ticker as ticker
 import matplotlib.cm as cm
@@ -20,9 +22,6 @@
 import matplotlib.patches as mpatches
 import matplotlib.transforms as mtransforms
 
-# Import needed for adding manual selection capability to clabel
-from matplotlib.blocking_input import BlockingContourLabeler
-from matplotlib import docstring
 
 # We can't use a single line collection for contour because a line
 # collection can have only a single line style, and we want to be able to have
@@ -45,6 +44,35 @@ def get_rotation(self):
         return new_angle
 
 
+def _contour_labeler_event_handler(cs, inline, inline_spacing, event):
+    canvas = cs.axes.figure.canvas
+    is_button = event.name == "button_press_event"
+    is_key = event.name == "key_press_event"
+    # Quit (even if not in infinite mode; this is consistent with
+    # MATLAB and sometimes quite useful, but will require the user to
+    # test how many points were actually returned before using data).
+    if (is_button and event.button == MouseButton.MIDDLE
+            or is_key and event.key in ["escape", "enter"]):
+        canvas.stop_event_loop()
+    # Pop last click.
+    elif (is_button and event.button == MouseButton.RIGHT
+          or is_key and event.key in ["backspace", "delete"]):
+        # Unfortunately, if one is doing inline labels, then there is currently
+        # no way to fix the broken contour - once humpty-dumpty is broken, he
+        # can't be put back together.  In inline mode, this does nothing.
+        if not inline:
+            cs.pop_label()
+            canvas.draw()
+    # Add new click.
+    elif (is_button and event.button == MouseButton.LEFT
+          # On macOS/gtk, some keys return None.
+          or is_key and event.key is not None):
+        if event.inaxes == cs.ax:
+            cs.add_label_near(event.x, event.y, transform=False,
+                              inline=inline, inline_spacing=inline_spacing)
+            canvas.draw()
+
+
 class ContourLabeler:
     """Mixin to provide labelling capability to `.ContourSet`."""
 
@@ -198,8 +226,11 @@ def clabel(self, levels=None, *,
             print('End manual selection with second mouse button.')
             if not inline:
                 print('Remove last label by clicking third mouse button.')
-            blocking_contour_labeler = BlockingContourLabeler(self)
-            blocking_contour_labeler(inline, inline_spacing)
+            mpl._blocking_input.blocking_input_loop(
+                self.axes.figure, ["button_press_event", "key_press_event"],
+                timeout=-1, handler=functools.partial(
+                    _contour_labeler_event_handler,
+                    self, inline, inline_spacing))
         else:
             self.labels(inline, inline_spacing)
 

lib/matplotlib/figure.py

@@ -22,7 +22,7 @@
 import numpy as np
 
 import matplotlib as mpl
-from matplotlib import docstring, projections
+from matplotlib import _blocking_input, docstring, projections
 from matplotlib.artist import (
     Artist, allow_rasterization, _finalize_rasterization)
 from matplotlib.backend_bases import (
@@ -33,7 +33,6 @@
 import matplotlib.image as mimage
 
 from matplotlib.axes import Axes, SubplotBase, subplot_class_factory
-from matplotlib.blocking_input import BlockingMouseInput, BlockingKeyMouseInput
 from matplotlib.gridspec import GridSpec
 import matplotlib.legend as mlegend
 from matplotlib.patches import Rectangle
@@ -3013,12 +3012,52 @@ def ginput(self, n=1, timeout=30, show_clicks=True,
         terminates input and any other key (not already used by the window
         manager) selects a point.
         """
-        blocking_mouse_input = BlockingMouseInput(self,
-                                                  mouse_add=mouse_add,
-                                                  mouse_pop=mouse_pop,
-                                                  mouse_stop=mouse_stop)
-        return blocking_mouse_input(n=n, timeout=timeout,
-                                    show_clicks=show_clicks)
+        clicks = []
+        marks = []
+
+        def handler(event):
+            is_button = event.name == "button_press_event"
+            is_key = event.name == "key_press_event"
+            # Quit (even if not in infinite mode; this is consistent with
+            # MATLAB and sometimes quite useful, but will require the user to
+            # test how many points were actually returned before using data).
+            if (is_button and event.button == mouse_stop
+                    or is_key and event.key in ["escape", "enter"]):
+                self.canvas.stop_event_loop()
+            # Pop last click.
+            elif (is_button and event.button == mouse_pop
+                  or is_key and event.key in ["backspace", "delete"]):
+                if clicks:
+                    clicks.pop()
+                    if show_clicks:
+                        marks.pop().remove()
+                        self.canvas.draw()
+            # Add new click.
+            elif (is_button and event.button == mouse_add
+                  # On macOS/gtk, some keys return None.
+                  or is_key and event.key is not None):
+                if event.inaxes:
+                    clicks.append((event.xdata, event.ydata))
+                    _log.info("input %i: %f, %f",
+                              len(clicks), event.xdata, event.ydata)
+                    if show_clicks:
+                        line = mpl.lines.Line2D([event.xdata], [event.ydata],
+                                                marker="+", color="r")
+                        event.inaxes.add_line(line)
+                        marks.append(line)
+                        self.canvas.draw()
+            if len(clicks) == n and n > 0:
+                self.canvas.stop_event_loop()
+
+        _blocking_input.blocking_input_loop(
+            self, ["button_press_event", "key_press_event"], timeout, handler)
+
+        # Cleanup.
+        for mark in marks:
+            mark.remove()
+        self.canvas.draw()
+
+        return clicks
 
     def waitforbuttonpress(self, timeout=-1):
         """
@@ -3028,8 +3067,17 @@ def waitforbuttonpress(self, timeout=-1):
         mouse button was pressed and None if no input was given within
         *timeout* seconds.  Negative values deactivate *timeout*.
         """
-        blocking_input = BlockingKeyMouseInput(self)
-        return blocking_input(timeout=timeout)
+        event = None
+
+        def handler(ev):
+            nonlocal event
+            event = ev
+            self.canvas.stop_event_loop()
+
+        _blocking_input.blocking_input_loop(
+            self, ["button_press_event", "key_press_event"], timeout, handler)
+
+        return None if event is None else event.name == "key_press_event"
 
     def init_layoutgrid(self):
         """Initialize the layoutgrid for use in constrained_layout."""