Move set_cursor from the toolbar to FigureCanvas.

While the toolbar does need to track what it wants to set the cursor to
based on the active tool, actually setting it is an act on the canvas
(or sometimes the window, but this is toolkit dependent, so we won't
worry about that.)

Author: QuLogic

lib/matplotlib/backend_bases.py

@@ -2011,6 +2011,24 @@ def release_mouse(self, ax):
         if self.mouse_grabber is ax:
             self.mouse_grabber = None
 
+    def set_cursor(self, cursor):
+        """
+        Set the current cursor.
+
+        This may have no effect if the backend does not display anything.
+
+        If required by the backend, this method should trigger an update in
+        the backend event loop after the cursor is set, as this method may be
+        called e.g. before a long-running task during which the GUI is not
+        updated.
+
+        Parameters
+        ----------
+        cursor : `.Cursors`
+            The cursor to dispay over the canvas. Note: some backends may
+            change the cursor for the entire window.
+        """
+
     def draw(self, *args, **kwargs):
         """
         Render the `.Figure`.
@@ -2914,7 +2932,7 @@ def __init__(self, canvas):
         canvas.toolbar = self
         self._nav_stack = cbook.Stack()
         # This cursor will be set after the initial draw.
-        self._lastCursor = cursors.POINTER
+        self._lastCursor = tools.Cursors.POINTER
 
         self._id_press = self.canvas.mpl_connect(
             'button_press_event', self._zoom_pan_handler)
@@ -2983,16 +3001,16 @@ def _update_cursor(self, event):
         """
         if self.mode and event.inaxes and event.inaxes.get_navigate():
             if (self.mode == _Mode.ZOOM
-                    and self._lastCursor != cursors.SELECT_REGION):
-                self.set_cursor(cursors.SELECT_REGION)
-                self._lastCursor = cursors.SELECT_REGION
+                    and self._lastCursor != tools.Cursors.SELECT_REGION):
+                self.canvas.set_cursor(tools.Cursors.SELECT_REGION)
+                self._lastCursor = tools.Cursors.SELECT_REGION
             elif (self.mode == _Mode.PAN
-                  and self._lastCursor != cursors.MOVE):
-                self.set_cursor(cursors.MOVE)
-                self._lastCursor = cursors.MOVE
-        elif self._lastCursor != cursors.POINTER:
-            self.set_cursor(cursors.POINTER)
-            self._lastCursor = cursors.POINTER
+                  and self._lastCursor != tools.Cursors.MOVE):
+                self.canvas.set_cursor(tools.Cursors.MOVE)
+                self._lastCursor = tools.Cursors.MOVE
+        elif self._lastCursor != tools.Cursors.POINTER:
+            self.canvas.set_cursor(tools.Cursors.POINTER)
+            self._lastCursor = tools.Cursors.POINTER
 
     @contextmanager
     def _wait_cursor_for_draw_cm(self):
@@ -3009,10 +3027,10 @@ def _wait_cursor_for_draw_cm(self):
             time.time(), getattr(self, "_draw_time", -np.inf))
         if self._draw_time - last_draw_time > 1:
             try:
-                self.set_cursor(cursors.WAIT)
+                self.canvas.set_cursor(tools.Cursors.WAIT)
                 yield
             finally:
-                self.set_cursor(self._lastCursor)
+                self.canvas.set_cursor(self._lastCursor)
         else:
             yield
 

lib/matplotlib/backend_tools.py

@@ -266,15 +266,15 @@ def _add_tool_cbk(self, event):
         self._add_tool(event.tool)
 
     def _set_cursor_cbk(self, event):
-        if not event:
+        if not event or not self.canvas:
             return
         if (self._current_tool and getattr(event, "inaxes", None)
                 and event.inaxes.get_navigate()):
             if self._last_cursor != self._current_tool.cursor:
-                self.set_cursor(self._current_tool.cursor)
+                self.canvas.set_cursor(self._current_tool.cursor)
                 self._last_cursor = self._current_tool.cursor
         elif self._last_cursor != self._default_cursor:
-            self.set_cursor(self._default_cursor)
+            self.canvas.set_cursor(self._default_cursor)
             self._last_cursor = self._default_cursor
 
     def set_cursor(self, cursor):

lib/matplotlib/backends/backend_gtk3.py

@@ -90,15 +90,15 @@ def _create_application():
 
 @functools.lru_cache()
 def _mpl_to_gtk_cursor(mpl_cursor):
-    name = {
+    name = _api.check_getitem({
         Cursors.MOVE: "move",
         Cursors.HAND: "pointer",
         Cursors.POINTER: "default",
         Cursors.SELECT_REGION: "crosshair",
         Cursors.WAIT: "wait",
         Cursors.RESIZE_HORIZONTAL: "ew-resize",
         Cursors.RESIZE_VERTICAL: "ns-resize",
-    }[mpl_cursor]
+    }, cursor=mpl_cursor)
     return Gdk.Cursor.new_from_name(Gdk.Display.get_default(), name)
 
 
@@ -188,6 +188,14 @@ def __init__(self, figure=None):
     def destroy(self):
         self.close_event()
 
+    def set_cursor(self, cursor):
+        # docstring inherited
+        window = self.get_property("window")
+        if window is not None:
+            window.set_cursor(_mpl_to_gtk_cursor(cursor))
+            context = GLib.MainContext.default()
+            context.iteration(True)
+
     def scroll_event(self, widget, event):
         x = event.x
         # flipy so y=0 is bottom of canvas
@@ -533,13 +541,6 @@ def set_message(self, s):
         escaped = GLib.markup_escape_text(s)
         self.message.set_markup(f'<small>{escaped}</small>')
 
-    def set_cursor(self, cursor):
-        window = self.canvas.get_property("window")
-        if window is not None:
-            window.set_cursor(_mpl_to_gtk_cursor(cursor))
-            context = GLib.MainContext.default()
-            context.iteration(True)
-
     def draw_rubberband(self, event, x0, y0, x1, y1):
         height = self.canvas.figure.bbox.height
         y1 = height - y1

lib/matplotlib/backends/backend_macosx.py

@@ -39,6 +39,10 @@ def _set_device_scale(self, value):
             self._dpi_ratio, old_value = value, self._dpi_ratio
             self.figure.dpi = self.figure.dpi / old_value * self._dpi_ratio
 
+    def set_cursor(self, cursor):
+        # docstring inherited
+        _macosx.set_cursor(cursor)
+
     def _draw(self):
         renderer = self.get_renderer(cleared=self.figure.stale)
         if self.figure.stale:
@@ -108,9 +112,6 @@ def release_zoom(self, event):
         super().release_zoom(event)
         self.canvas.remove_rubberband()
 
-    def set_cursor(self, cursor):
-        _macosx.set_cursor(cursor)
-
     def save_figure(self, *args):
         filename = _macosx.choose_save_file('Save the figure',
                                             self.canvas.get_default_filename())

lib/matplotlib/backends/backend_qt5.py

@@ -241,6 +241,10 @@ def showEvent(self, event):
         window.screenChanged.connect(self._update_screen)
         self._update_screen(window.screen())
 
+    def set_cursor(self, cursor):
+        # docstring inherited
+        self.setCursor(_api.check_getitem(cursord, cursor=cursor))
+
     def enterEvent(self, event):
         try:
             x, y = self.mouseEventCoords(event.pos())
@@ -702,9 +706,6 @@ def set_message(self, s):
         if self.coordinates:
             self.locLabel.setText(s)
 
-    def set_cursor(self, cursor):
-        self.canvas.setCursor(cursord[cursor])
-
     def draw_rubberband(self, event, x0, y0, x1, y1):
         height = self.canvas.figure.bbox.height
         y1 = height - y1

lib/matplotlib/backends/backend_webagg_core.py

@@ -157,6 +157,19 @@ def blit(self, bbox=None):
     def draw_idle(self):
         self.send_event("draw")
 
+    def set_cursor(self, cursor):
+        # docstring inherited
+        cursor = _api.check_getitem({
+            backend_tools.Cursors.HAND: 'pointer',
+            backend_tools.Cursors.POINTER: 'default',
+            backend_tools.Cursors.SELECT_REGION: 'crosshair',
+            backend_tools.Cursors.MOVE: 'move',
+            backend_tools.Cursors.WAIT: 'wait',
+            backend_tools.Cursors.RESIZE_HORIZONTAL: 'ew-resize',
+            backend_tools.Cursors.RESIZE_VERTICAL: 'ns-resize',
+        }, cursor=cursor)
+        self.send_event('cursor', cursor=cursor)
+
     def set_image_mode(self, mode):
         """
         Set the image mode for any subsequent images which will be sent
@@ -362,30 +375,18 @@ class NavigationToolbar2WebAgg(backend_bases.NavigationToolbar2):
         if name_of_method in _ALLOWED_TOOL_ITEMS
     ]
 
+    cursor = _api.deprecate_privatize_attribute("3.5")
+
     def __init__(self, canvas):
         self.message = ''
-        self.cursor = None
+        self._cursor = None  # Remove with deprecation.
         super().__init__(canvas)
 
     def set_message(self, message):
         if message != self.message:
             self.canvas.send_event("message", message=message)
         self.message = message
 
-    def set_cursor(self, cursor):
-        if cursor != self.cursor:
-            cursor = {
-                backend_tools.Cursors.HAND: 'pointer',
-                backend_tools.Cursors.POINTER: 'default',
-                backend_tools.Cursors.SELECT_REGION: 'crosshair',
-                backend_tools.Cursors.MOVE: 'move',
-                backend_tools.Cursors.WAIT: 'wait',
-                backend_tools.Cursors.RESIZE_HORIZONTAL: 'ew-resize',
-                backend_tools.Cursors.RESIZE_VERTICAL: 'ns-resize',
-            }[cursor]
-            self.canvas.send_event("cursor", cursor=cursor)
-        self.cursor = cursor
-
     def draw_rubberband(self, event, x0, y0, x1, y1):
         self.canvas.send_event(
             "rubberband", x0=x0, y0=y0, x1=x1, y1=y1)

lib/matplotlib/backends/backend_wx.py

@@ -719,6 +719,12 @@ def _onKeyUp(self, event):
         if self:
             event.Skip()
 
+    def set_cursor(self, cursor):
+        # docstring inherited
+        cursor = wx.Cursor(_api.check_getitem(cursord, cursor=cursor))
+        self.SetCursor(cursor)
+        self.Update()
+
     def _set_capture(self, capture=True):
         """Control wx mouse capture."""
         if self.HasCapture():
@@ -1155,11 +1161,6 @@ def save_figure(self, *args):
             except Exception as e:
                 error_msg_wx(str(e))
 
-    def set_cursor(self, cursor):
-        cursor = wx.Cursor(cursord[cursor])
-        self.canvas.SetCursor(cursor)
-        self.canvas.Update()
-
     def draw_rubberband(self, event, x0, y0, x1, y1):
         height = self.canvas.figure.bbox.height
         self.canvas._rubberband_rect = (x0, height - y0, x1, height - y1)