Merge pull request matplotlib#20208 from anntzer/simple-blocking-input

Rewrite blocking_input to something much simpler.

Author: timhoffm

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
@@ -3027,12 +3026,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):
         """
@@ -3042,8 +3081,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."""