axes_grid1: add host/parasite axes pick methods

smheidrich · smheidrich · commit 7d40bc805708 · 2019-01-04T16:02:23.000+01:00
Fixes #5581
diff --git a/lib/mpl_toolkits/axes_grid1/parasite_axes.py b/lib/mpl_toolkits/axes_grid1/parasite_axes.py
@@ -36,6 +36,36 @@ def cla(self):
             self.xaxis.set_zorder(2.5)
             self.yaxis.set_zorder(2.5)
 
+    # Overwritten so events that actually happened in the host axes still count
+    def pick(self, mouseevent):
+        """
+        call signature::
+
+          pick(mouseevent)
+
+        each child artist will fire a pick event if *mouseevent* is over
+        the artist and the artist has picker set
+        """
+        # Pick self
+        if self.pickable():
+            picker = self.get_picker()
+            if callable(picker):
+                inside, prop = picker(self, mouseevent)
+            else:
+                inside, prop = self.contains(mouseevent)
+            if inside:
+                self.figure.canvas.pick_event(mouseevent, self, **prop)
+
+        # Pick children
+        for a in self.get_children():
+            # make sure the event happened in the same axes (never happens but
+            # whatever) or in host axes
+            ax = getattr(a, 'axes', None)
+            if mouseevent.inaxes is None or ax is None or \
+                    mouseevent.inaxes == ax or \
+                    (hasattr(mouseevent.inaxes, "parasites") and
+                    self in mouseevent.inaxes.parasites):
+                a.pick(mouseevent)
 
 @functools.lru_cache(None)
 def parasite_axes_class_factory(axes_class=None):
@@ -232,6 +262,45 @@ def cla(self):
             ax.cla()
         super().cla()
 
+    # Need to overwrite this so children of parasite axes get picked as well
+    def pick(self, mouseevent):
+        """
+        call signature::
+
+          pick(mouseevent)
+
+        each child artist will fire a pick event if *mouseevent* is over
+        the artist and the artist has picker set
+        """
+        # Pick self
+        if self.pickable():
+            picker = self.get_picker()
+            if callable(picker):
+                inside, prop = picker(self, mouseevent)
+            else:
+                inside, prop = self.contains(mouseevent)
+            if inside:
+                self.figure.canvas.pick_event(mouseevent, self, **prop)
+
+        # Pick children
+        for a in self.get_children():
+            # make sure the event happened in the same axes
+            ax = getattr(a, 'axes', None)
+            if mouseevent.inaxes is None or ax is None or \
+                    mouseevent.inaxes == ax:
+                # we need to check if mouseevent.inaxes is None
+                # because some objects associated with an axes (e.g., a
+                # tick label) can be outside the bounding box of the
+                # axes and inaxes will be None
+                # also check that ax is None so that it traverse objects
+                # which do no have an axes property but children might
+                a.pick(mouseevent)
+
+        # Pick parasite axes
+        for a in self.parasites:
+            a.pick(mouseevent)
+
+
     def twinx(self, axes_class=None):
         """
         create a twin of Axes for generating a plot with a sharex
diff --git a/lib/mpl_toolkits/tests/test_axes_grid1.py b/lib/mpl_toolkits/tests/test_axes_grid1.py
@@ -17,16 +17,20 @@
     AnchoredSizeBar,
     AnchoredDirectionArrows)
 
+from matplotlib.backend_bases import MouseEvent
 from matplotlib.colors import LogNorm
 from matplotlib.transforms import Bbox, TransformedBbox
 from itertools import product
+import queue
 
 import pytest
 import platform
 
 import numpy as np
 from numpy.testing import assert_array_equal, assert_array_almost_equal
 
+import pytest
+
 
 @image_comparison(baseline_images=['divider_append_axes'])
 def test_divider_append_axes():
@@ -422,3 +426,69 @@ def test_gettightbbox():
     bbox = fig.get_tightbbox(fig.canvas.get_renderer())
     np.testing.assert_array_almost_equal(bbox.extents,
                                          [-17.7, -13.9, 7.2, 5.4])
+
+
+class TestPickingCallbacksOverlap(object):
+    """Test pick events on normal, host or parasite axes."""
+    # Two rectangles are drawn and "clicked on", a small one and a big one
+    # enclosing the small one. The axis on which they are drawn as well as the
+    # rectangle that is clicked on are varied.
+    # In each case we expect that both rectangles are picked if we click on the
+    # small one and only the big one is picked if we click on the big one.
+    # Also tests picking on normal axes ("gca") as a control.
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        self.q = queue.Queue()
+        self.big = plt.Rectangle((0.25, 0.25), 0.5, 0.5, picker=5)
+        self.small = plt.Rectangle((0.4, 0.4), 0.2, 0.2, facecolor="r",
+            picker=5)
+        plt.gcf().canvas.mpl_connect('pick_event', self.on_pick)
+
+    def on_pick(self, event):
+        self.q.put(event)
+
+    @pytest.mark.parametrize("click_on", [ "big", "small" ])
+    @pytest.mark.parametrize("big_on_axes,small_on_axes", [
+        ("gca", "gca"),
+        ("host", "host"),
+        ("host", "parasite"),
+        ("parasite", "host"),
+        ("parasite", "parasite")
+    ])
+    def test_picking_simple(self, big_on_axes, small_on_axes, click_on):
+        # Shortcut
+        rectangles_on_axes = (big_on_axes, small_on_axes)
+        # Axes setup
+        axes = { "gca": None, "host": None, "parasite": None }
+        if "gca" in rectangles_on_axes:
+            axes["gca"] = plt.gca()
+        if "host" in rectangles_on_axes or "parasite" in rectangles_on_axes:
+            axes["host"] = host_subplot(111)
+            axes["parasite"] = axes["host"].twin()
+        # Add rectangles to axes
+        axes[big_on_axes].add_patch(self.big)
+        axes[small_on_axes].add_patch(self.small)
+        # Simulate picking with click mouse event
+        if click_on == "big":
+            click_axes = axes[big_on_axes]
+            axes_coords = (0.3, 0.3)
+        else:
+            click_axes = axes[small_on_axes]
+            axes_coords = (0.5, 0.5)
+        # In reality mouse events never happen on parasite axes, only host axes
+        if click_axes is axes["parasite"]:
+            click_axes = axes["host"]
+        (x, y) = click_axes.transAxes.transform(axes_coords)
+        m = MouseEvent("button_press_event", click_axes.figure.canvas, x, y,
+        button=1)
+        click_axes.pick(m)
+        # Wait at most a second for events; actual waiting only happens if sth.
+        # is wrong and tests fail, so this won't slow down normal testing
+        n_events = 2 if click_on == "small" else 1
+        event_rects = []
+        for i in range(n_events):
+            event = self.q.get(True, 0.5)
+            event_rects.append(event.artist)
+        assert self.big in event_rects
+        if click_on == "small":
+            assert self.small in event_rects
