In Artist.contains, check that moussevents occurred on the right canvas.

anntzer · anntzer · commit a6230cc72009 · 2023-03-26T20:16:37.000+02:00
The old _default_contains check was geared towards custom contains
checkers (set via set_contains), which have been removed.  Get rid of
that and instead, add a check for canvas identity which is more useful.
diff --git a/lib/matplotlib/artist.py b/lib/matplotlib/artist.py
@@ -461,28 +461,22 @@ def get_children(self):
         r"""Return a list of the child `.Artist`\s of this `.Artist`."""
         return []
 
-    def _default_contains(self, mouseevent, figure=None):
+    def _different_canvas(self, event):
         """
-        Base impl. for checking whether a mouseevent happened in an artist.
+        Check whether an *event* occurred on a canvas other that this artist's canvas.
 
-        1. If the artist figure is known and the event did not occur in that
-           figure (by checking its ``canvas`` attribute), reject it.
-        2. Otherwise, return `None, {}`, indicating that the subclass'
-           implementation should be used.
+        If this method returns True, the event definitely occurred on a different
+        canvas; if it returns False, either it occurred on the same canvas, or we may
+        not have enough information to know.
 
-        Subclasses should start their definition of `contains` as follows:
+        Subclasses should start their definition of `contains` as follows::
 
-            inside, info = self._default_contains(mouseevent)
-            if inside is not None:
-                return inside, info
+            if self._different_canvas(mouseevent):
+                return False, {}
             # subclass-specific implementation follows
-
-        The *figure* kwarg is provided for the implementation of
-        `.Figure.contains`.
         """
-        if figure is not None and mouseevent.canvas is not figure.canvas:
-            return False, {}
-        return None, {}
+        return (getattr(event, "canvas", None) is not None and self.figure is not None
+                and event.canvas is not self.figure.canvas)
 
     def contains(self, mouseevent):
         """
diff --git a/lib/matplotlib/axes/_base.py b/lib/matplotlib/axes/_base.py
@@ -4271,9 +4271,6 @@ def get_children(self):
 
     def contains(self, mouseevent):
         # docstring inherited.
-        inside, info = self._default_contains(mouseevent)
-        if inside is not None:
-            return inside, info
         return self.patch.contains(mouseevent)
 
     def contains_point(self, point):
diff --git a/lib/matplotlib/axis.py b/lib/matplotlib/axis.py
@@ -242,9 +242,6 @@ def contains(self, mouseevent):
         This function always returns false.  It is more useful to test if the
         axis as a whole contains the mouse rather than the set of tick marks.
         """
-        inside, info = self._default_contains(mouseevent)
-        if inside is not None:
-            return inside, info
         return False, {}
 
     def set_pad(self, val):
@@ -2230,10 +2227,8 @@ def _init(self):
 
     def contains(self, mouseevent):
         """Test whether the mouse event occurred in the x-axis."""
-        inside, info = self._default_contains(mouseevent)
-        if inside is not None:
-            return inside, info
-
+        if self._different_canvas(mouseevent):
+            return False, {}
         x, y = mouseevent.x, mouseevent.y
         try:
             trans = self.axes.transAxes.inverted()
@@ -2473,10 +2468,8 @@ def _init(self):
 
     def contains(self, mouseevent):
         # docstring inherited
-        inside, info = self._default_contains(mouseevent)
-        if inside is not None:
-            return inside, info
-
+        if self._different_canvas(mouseevent):
+            return False, {}
         x, y = mouseevent.x, mouseevent.y
         try:
             trans = self.axes.transAxes.inverted()
diff --git a/lib/matplotlib/collections.py b/lib/matplotlib/collections.py
@@ -454,24 +454,16 @@ def contains(self, mouseevent):
         Returns ``bool, dict(ind=itemlist)``, where every item in itemlist
         contains the event.
         """
-        inside, info = self._default_contains(mouseevent)
-        if inside is not None:
-            return inside, info
-
-        if not self.get_visible():
+        if self._different_canvas(mouseevent) or not self.get_visible():
             return False, {}
-
         pickradius = (
             float(self._picker)
             if isinstance(self._picker, Number) and
                self._picker is not True  # the bool, not just nonzero or 1
             else self._pickradius)
-
         if self.axes:
             self.axes._unstale_viewLim()
-
         transform, offset_trf, offsets, paths = self._prepare_points()
-
         # Tests if the point is contained on one of the polygons formed
         # by the control points of each of the paths. A point is considered
         # "on" a path if it would lie within a stroke of width 2*pickradius
@@ -481,7 +473,6 @@ def contains(self, mouseevent):
             mouseevent.x, mouseevent.y, pickradius,
             transform.frozen(), paths, self.get_transforms(),
             offsets, offset_trf, pickradius <= 0)
-
         return len(ind) > 0, dict(ind=ind)
 
     def set_urls(self, urls):
diff --git a/lib/matplotlib/figure.py b/lib/matplotlib/figure.py
@@ -289,9 +289,8 @@ def contains(self, mouseevent):
         -------
             bool, {}
         """
-        inside, info = self._default_contains(mouseevent, figure=self)
-        if inside is not None:
-            return inside, info
+        if self._different_canvas(mouseevent):
+            return False, {}
         inside = self.bbox.contains(mouseevent.x, mouseevent.y)
         return inside, {}
 
diff --git a/lib/matplotlib/image.py b/lib/matplotlib/image.py
@@ -654,9 +654,8 @@ def draw(self, renderer, *args, **kwargs):
 
     def contains(self, mouseevent):
         """Test whether the mouse event occurred within the image."""
-        inside, info = self._default_contains(mouseevent)
-        if inside is not None:
-            return inside, info
+        if self._different_canvas(mouseevent):
+            return False, {}
         # 1) This doesn't work for figimage; but figimage also needs a fix
         #    below (as the check cannot use x/ydata and extents).
         # 2) As long as the check below uses x/ydata, we need to test axes
@@ -1468,16 +1467,10 @@ def get_window_extent(self, renderer=None):
 
     def contains(self, mouseevent):
         """Test whether the mouse event occurred within the image."""
-        inside, info = self._default_contains(mouseevent)
-        if inside is not None:
-            return inside, info
-
-        if not self.get_visible():  # or self.get_figure()._renderer is None:
+        if self._different_canvas(mouseevent) or not self.get_visible():
             return False, {}
-
         x, y = mouseevent.x, mouseevent.y
         inside = self.get_window_extent().contains(x, y)
-
         return inside, {}
 
     def make_image(self, renderer, magnification=1.0, unsampled=False):
diff --git a/lib/matplotlib/legend.py b/lib/matplotlib/legend.py
@@ -1174,9 +1174,6 @@ def _find_best_position(self, width, height, renderer, consider=None):
         return l, b
 
     def contains(self, event):
-        inside, info = self._default_contains(event)
-        if inside is not None:
-            return inside, info
         return self.legendPatch.contains(event)
 
     def set_draggable(self, state, use_blit=False, update='loc'):
diff --git a/lib/matplotlib/lines.py b/lib/matplotlib/lines.py
@@ -447,9 +447,8 @@ def contains(self, mouseevent):
 
             TODO: sort returned indices by distance
         """
-        inside, info = self._default_contains(mouseevent)
-        if inside is not None:
-            return inside, info
+        if self._different_canvas(mouseevent):
+            return False, {}
 
         # Make sure we have data to plot
         if self._invalidy or self._invalidx:
diff --git a/lib/matplotlib/offsetbox.py b/lib/matplotlib/offsetbox.py
@@ -268,9 +268,8 @@ def contains(self, mouseevent):
         --------
         .Artist.contains
         """
-        inside, info = self._default_contains(mouseevent)
-        if inside is not None:
-            return inside, info
+        if self._different_canvas(mouseevent):
+            return False, {}
         for c in self.get_children():
             a, b = c.contains(mouseevent)
             if a:
@@ -1353,9 +1352,8 @@ def anncoords(self, coords):
         self.stale = True
 
     def contains(self, mouseevent):
-        inside, info = self._default_contains(mouseevent)
-        if inside is not None:
-            return inside, info
+        if self._different_canvas(mouseevent):
+            return False, {}
         if not self._check_xy(None):
             return False, {}
         return self.offsetbox.contains(mouseevent)
diff --git a/lib/matplotlib/patches.py b/lib/matplotlib/patches.py
@@ -132,9 +132,8 @@ def contains(self, mouseevent, radius=None):
         -------
         (bool, empty dict)
         """
-        inside, info = self._default_contains(mouseevent)
-        if inside is not None:
-            return inside, info
+        if self._different_canvas(mouseevent):
+            return False, {}
         radius = self._process_radius(radius)
         codes = self.get_path().codes
         if codes is not None:
diff --git a/lib/matplotlib/quiver.py b/lib/matplotlib/quiver.py
@@ -374,9 +374,8 @@ def set_figure(self, fig):
         self.text.set_figure(fig)
 
     def contains(self, mouseevent):
-        inside, info = self._default_contains(mouseevent)
-        if inside is not None:
-            return inside, info
+        if self._different_canvas(mouseevent):
+            return False, {}
         # Maybe the dictionary should allow one to
         # distinguish between a text hit and a vector hit.
         if (self.text.contains(mouseevent)[0] or
diff --git a/lib/matplotlib/table.py b/lib/matplotlib/table.py
@@ -426,9 +426,8 @@ def _get_grid_bbox(self, renderer):
 
     def contains(self, mouseevent):
         # docstring inherited
-        inside, info = self._default_contains(mouseevent)
-        if inside is not None:
-            return inside, info
+        if self._different_canvas(mouseevent):
+            return False, {}
         # TODO: Return index of the cell containing the cursor so that the user
         # doesn't have to bind to each one individually.
         renderer = self.figure._get_renderer()
diff --git a/lib/matplotlib/text.py b/lib/matplotlib/text.py
@@ -213,28 +213,22 @@ def contains(self, mouseevent):
         Return whether the mouse event occurred inside the axis-aligned
         bounding-box of the text.
         """
-        inside, info = self._default_contains(mouseevent)
-        if inside is not None:
-            return inside, info
-
-        if not self.get_visible() or self._renderer is None:
+        if (self._different_canvas(mouseevent) or not self.get_visible()
+                or self._renderer is None):
             return False, {}
-
         # Explicitly use Text.get_window_extent(self) and not
         # self.get_window_extent() so that Annotation.contains does not
         # accidentally cover the entire annotation bounding box.
         bbox = Text.get_window_extent(self)
         inside = (bbox.x0 <= mouseevent.x <= bbox.x1
                   and bbox.y0 <= mouseevent.y <= bbox.y1)
-
         cattr = {}
         # if the text has a surrounding patch, also check containment for it,
         # and merge the results with the results for the text.
         if self._bbox_patch:
             patch_inside, patch_cattr = self._bbox_patch.contains(mouseevent)
             inside = inside or patch_inside
             cattr["bbox_patch"] = patch_cattr
-
         return inside, cattr
 
     def _get_xy_display(self):
@@ -1855,9 +1849,8 @@ def transform(renderer) -> Transform
         Text.__init__(self, x, y, text, **kwargs)
 
     def contains(self, event):
-        inside, info = self._default_contains(event)
-        if inside is not None:
-            return inside, info
+        if self._different_canvas(event):
+            return False, {}
         contains, tinfo = Text.contains(self, event)
         if self.arrow_patch is not None:
             in_patch, _ = self.arrow_patch.contains(event)
