ENH: Add a LockableBbox type.

QuLogic · QuLogic · commit 7ea2b5852a86 · 2017-07-27T00:19:37.000-04:00
This encapsulates another Bbox and locks one or more ends so that they
cannot be changed even if the corresponding element in the underlying
Bbox does.
diff --git a/lib/matplotlib/transforms.py b/lib/matplotlib/transforms.py
@@ -1095,6 +1095,155 @@ def get_points(self):
             return points
 
 
+class LockableBbox(BboxBase):
+    """
+    A :class:`Bbox` where some elements may be locked at certain values.
+
+    When the child bounding box changes, the bounds of this bbox will update
+    accordingly with the exception of the locked elements.
+    """
+    def __init__(self, bbox, x0=None, y0=None, x1=None, y1=None, **kwargs):
+        """
+        Parameters
+        ----------
+        bbox : Bbox
+            The child bounding box to wrap.
+
+        x0 : float or None
+            The locked value for x0, or None to leave unlocked.
+
+        y0 : float or None
+            The locked value for y0, or None to leave unlocked.
+
+        x1 : float or None
+            The locked value for x1, or None to leave unlocked.
+
+        y1 : float or None
+            The locked value for y1, or None to leave unlocked.
+
+        """
+        if not bbox.is_bbox:
+            raise ValueError("'bbox' is not a bbox")
+
+        BboxBase.__init__(self, **kwargs)
+        self._bbox = bbox
+        self.set_children(bbox)
+        self._points = None
+        fp = [x0, y0, x1, y1]
+        mask = [val is None for val in fp]
+        self._locked_points = np.ma.array(fp, np.float_,
+                                          mask=mask).reshape((2, 2))
+
+    def __repr__(self):
+        return "LockableBbox(%r, %r)" % (self._bbox, self._locked_points)
+
+    def get_points(self):
+        if self._invalid:
+            points = self._bbox.get_points()
+            self._points = np.where(self._locked_points.mask,
+                                    points,
+                                    self._locked_points)
+            self._invalid = 0
+        return self._points
+    get_points.__doc__ = Bbox.get_points.__doc__
+
+    if DEBUG:
+        _get_points = get_points
+
+        def get_points(self):
+            points = self._get_points()
+            self._check(points)
+            return points
+
+    def set_locked_x0(self, x0):
+        """
+        Set the value to be used for the locked x0.
+
+        Parameters
+        ----------
+        x0 : float or None
+            The locked value for x0, or None to unlock.
+        """
+        self._locked_points.mask[0, 0] = x0 is None
+        self._locked_points.data[0, 0] = x0
+        self.invalidate()
+
+    def get_locked_x0(self):
+        """
+        Get the value used for the locked x0.
+        """
+        if self._locked_points.mask[0, 0]:
+            return None
+        else:
+            return self._locked_points[0, 0]
+
+    def set_locked_y0(self, y0):
+        """
+        Set the value to be used for the locked y0.
+
+        Parameters
+        ----------
+        y0 : float or None
+            The locked value for y0, or None to unlock.
+        """
+        self._locked_points.mask[0, 1] = y0 is None
+        self._locked_points.data[0, 1] = y0
+        self.invalidate()
+
+    def get_locked_y0(self):
+        """
+        Get the value used for the locked y0.
+        """
+        if self._locked_points.mask[0, 1]:
+            return None
+        else:
+            return self._locked_points[0, 1]
+
+    def set_locked_x1(self, x1):
+        """
+        Set the value to be used for the locked x1.
+
+        Parameters
+        ----------
+        x1 : float or None
+            The locked value for x1, or None to unlock.
+        """
+        self._locked_points.mask[1, 0] = x1 is None
+        self._locked_points.data[1, 0] = x1
+        self.invalidate()
+
+    def get_locked_x1(self):
+        """
+        Get the value used for the locked x1.
+        """
+        if self._locked_points.mask[1, 0]:
+            return None
+        else:
+            return self._locked_points[1, 0]
+
+    def set_locked_y1(self, y1):
+        """
+        Set the value to be used for the locked y1.
+
+        Parameters
+        ----------
+        y1 : float or None
+            The locked value for y1, or None to unlock.
+        """
+        self._locked_points.mask[1, 1] = y1 is None
+        self._locked_points.data[1, 1] = y1
+        self.invalidate()
+
+    def get_locked_y1(self):
+        """
+        Get the value used for the locked y1.
+        """
+        if self._locked_points.mask[1, 1]:
+            return None
+        else:
+            return self._locked_points[1, 1]
+
+
 class Transform(TransformNode):
     """
     The base class of all :class:`TransformNode` instances that
