Cleaner variable names

dstansby · dstansby · commit 09942f041777 · 2021-12-10T18:30:47.000Z
diff --git a/lib/matplotlib/widgets.py b/lib/matplotlib/widgets.py
@@ -3056,37 +3056,35 @@ def _onmove(self, event):
         state = self._state
         rotate = ('rotate' in state and
                   self._active_handle in self._corner_order)
-        eventpress = self._eventpress
+        xy = np.array([event.xdata, event.ydata])
+        xy_press = np.array([self._eventpress.xdata, self._eventpress.ydata])
+
         # The calculations are done for rotation at zero: we apply inverse
         # transformation to events except when we rotate and move
         move = self._active_handle == 'C'
         if not move and not rotate:
             inv_tr = self._get_rotation_transform().inverted()
-            event.xdata, event.ydata = inv_tr.transform(
-                [event.xdata, event.ydata])
-            eventpress.xdata, eventpress.ydata = inv_tr.transform(
-                [eventpress.xdata, eventpress.ydata]
-                )
+            xy = inv_tr.transform(xy)
+            xy_press = inv_tr.transform(xy_press)
 
-        dx = event.xdata - eventpress.xdata
-        dy = event.ydata - eventpress.ydata
+        dxy = xy - xy_press
         # refmax is used when moving the corner handle with the square state
         # and is the maximum between refx and refy
         refmax = None
         if self._use_data_coordinates:
-            refx, refy = dx, dy
+            refx, refy = dxy
         else:
             # Add 1e-6 to avoid divided by zero error
-            refx = event.xdata / (eventpress.xdata or 1E-6)
-            refy = event.ydata / (eventpress.ydata or 1E-6)
+            refx = xy[0] / (xy_press[0] or 1E-6)
+            refy = xy[1] / (xy_press[1] or 1E-6)
 
         x0, x1, y0, y1 = self._extents_on_press
         # rotate an existing shape
         if rotate:
             # calculate angle abc
-            a = np.array([eventpress.xdata, eventpress.ydata])
+            a = xy_press
             b = np.array(self.center)
-            c = np.array([event.xdata, event.ydata])
+            c = xy
             angle = (np.arctan2(c[1]-b[1], c[0]-b[0]) -
                      np.arctan2(a[1]-b[1], a[0]-b[0]))
             self.rotation = np.rad2deg(self._rotation_on_press + angle)
@@ -3104,19 +3102,19 @@ def _onmove(self, event):
                     if self._active_handle in self._corner_order:
                         refmax = max(refx, refy, key=abs)
                     if self._active_handle in ['E', 'W'] or refmax == refx:
-                        hw = event.xdata - center[0]
+                        hw = xy[0] - center[0]
                         hh = hw / self._aspect_ratio_correction
                     else:
-                        hh = event.ydata - center[1]
+                        hh = xy[1] - center[1]
                         hw = hh * self._aspect_ratio_correction
                 else:
                     hw = size_on_press[0] / 2
                     hh = size_on_press[1] / 2
                     # cancel changes in perpendicular direction
                     if self._active_handle in ['E', 'W'] + self._corner_order:
-                        hw = abs(event.xdata - center[0])
+                        hw = abs(xy[0] - center[0])
                     if self._active_handle in ['N', 'S'] + self._corner_order:
-                        hh = abs(event.ydata - center[1])
+                        hh = abs(xy[1] - center[1])
 
                 x0, x1, y0, y1 = (center[0] - hw, center[0] + hw,
                                   center[1] - hh, center[1] + hh)
@@ -3129,31 +3127,29 @@ def _onmove(self, event):
                 if 'S' in self._active_handle:
                     y0 = y1
                 if self._active_handle in ['E', 'W'] + self._corner_order:
-                    x1 = event.xdata
+                    x1 = xy[0]
                 if self._active_handle in ['N', 'S'] + self._corner_order:
-                    y1 = event.ydata
+                    y1 = xy[1]
                 if 'square' in state:
                     # when using a corner, find which reference to use
                     if self._active_handle in self._corner_order:
                         refmax = max(refx, refy, key=abs)
                     if self._active_handle in ['E', 'W'] or refmax == refx:
-                        sign = np.sign(event.ydata - y0)
+                        sign = np.sign(xy[1] - y0)
                         y1 = y0 + sign * abs(x1 - x0) / \
                             self._aspect_ratio_correction
                     else:
-                        sign = np.sign(event.xdata - x0)
+                        sign = np.sign(xy[0] - x0)
                         x1 = x0 + sign * abs(y1 - y0) * \
                             self._aspect_ratio_correction
 
         # move existing shape
         elif self._active_handle == 'C':
             x0, x1, y0, y1 = self._extents_on_press
-            dx = event.xdata - eventpress.xdata
-            dy = event.ydata - eventpress.ydata
-            x0 += dx
-            x1 += dx
-            y0 += dy
-            y1 += dy
+            x0 += dxy[0]
+            x1 += dxy[0]
+            y0 += dxy[1]
+            y1 += dxy[1]
 
         # new shape
         else:
@@ -3162,7 +3158,7 @@ def _onmove(self, event):
             # ignore_event_outside=True
             if self.ignore_event_outside and self._selection_completed:
                 return
-            center = [eventpress.xdata, eventpress.ydata]
+            center = xy_press
             dx = (event.xdata - center[0]) / 2.
             dy = (event.ydata - center[1]) / 2.
 
