Source code for enable.layout.geometry

# (C) Copyright 2005-2022 Enthought, Inc., Austin, TX
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in LICENSE.txt and may be redistributed only under
# the conditions described in the aforementioned license. The license
# is also available online at http://www.enthought.com/licenses/BSD.txt
#
# Thanks for using Enthought open source!

# -----------------------------------------------------------------------------
# Rect
# -----------------------------------------------------------------------------
[docs]class BaseRect(tuple): """ A tuple subclass representing an (x, y, width, height) bounding box. Subclasses should override the __new__ method to enforce any necessary typing. """ __slots__ = () def __new__(cls, x, y, width, height): return super(BaseRect, cls).__new__(cls, (x, y, width, height)) def __getnewargs__(self): return tuple(self) def __repr__(self): template = "%s(x=%s, y=%s, width=%s, height=%s)" values = (self.__class__.__name__,) + self return template % values @property def x(self): """ The 'x' position component of the rect. """ return self[0] @property def y(self): """ The 'y' position component of the rect. """ return self[1] @property def width(self): """ The 'width' size component of the rect. """ return self[2] @property def height(self): """ The 'height' size component of the rect. """ return self[3]
[docs]class Rect(BaseRect): """ A BaseRect implementation for integer values. """ __slots__ = () def __new__(cls, x, y, width, height): i = int return super(Rect, cls).__new__(cls, i(x), i(y), i(width), i(height)) @property def box(self): """ The equivalent Box for this rect. """ x, y, width, height = self return Box(y, x + width, y + height, x) @property def pos(self): """ The position of the rect as a Pos object. """ return Pos(self.x, self.y) @property def size(self): """ The size of the rect as a Size object. """ return Size(self.width, self.height)
[docs]class RectF(BaseRect): """ A BaseRect implementation for floating point values. """ __slots__ = () def __new__(cls, x, y, width, height): f = float return super(RectF, cls).__new__(cls, f(x), f(y), f(width), f(height)) @property def box(self): """ The equivalent Box for this rect. """ x, y, width, height = self return BoxF(y, x + width, y + height, x) @property def pos(self): """ The position of the rect as a Pos object. """ return PosF(self.x, self.y) @property def size(self): """ The size of the rect as a Size object. """ return SizeF(self.width, self.height)
# ----------------------------------------------------------------------------- # Box # -----------------------------------------------------------------------------
[docs]class BaseBox(tuple): """ A tuple subclass representing a (top, right, bottom, left) box. Subclasses should override the __new__ method to enforce any typing. """ __slots__ = ()
[docs] @staticmethod def coerce_type(item): return item
def __new__(cls, top=None, right=None, bottom=None, left=None): if isinstance(top, (tuple, BaseBox)): return cls(*top) c = cls.coerce_type top = c(top) if right is None: right = top else: right = c(right) if bottom is None: bottom = top else: bottom = c(bottom) if left is None: left = right else: left = c(left) return super(BaseBox, cls).__new__(cls, (top, right, bottom, left)) def __getnewargs__(self): return tuple(self) def __repr__(self): template = "%s(top=%s, right=%s, bottom=%s, left=%s)" values = (self.__class__.__name__,) + self return template % values @property def top(self): """ The 'top' component of the box. """ return self[0] @property def right(self): """ The 'right' component of the box. """ return self[1] @property def bottom(self): """ The 'bottom' component of the box. """ return self[2] @property def left(self): """ The 'left' component of the box. """ return self[3]
[docs]class Box(BaseBox): """ A BaseBox implementation for integer values. """ __slots__ = ()
[docs] @staticmethod def coerce_type(item): return 0 if item is None else int(item)
@property def rect(self): """ The equivalent Rect for this box. """ top, right, bottom, left = self return Rect(left, top, right - left, bottom - top) @property def size(self): """ The Size of this box. """ top, right, bottom, left = self return Size(right - left, bottom - top) @property def pos(self): """ The Pos of this box. """ return Pos(self.left, self.top)
[docs]class BoxF(BaseBox): """ A BaseBox implementation for floating point values. """ __slots__ = ()
[docs] @staticmethod def coerce_type(item): return 0.0 if item is None else float(item)
@property def rect(self): """ The equivalent Rect for this box. """ top, right, bottom, left = self return RectF(left, top, right - left, bottom - top) @property def size(self): """ The Size of this box. """ top, right, bottom, left = self return SizeF(right - left, bottom - top) @property def pos(self): """ The Pos of this box. """ return PosF(self.left, self.top)
# ----------------------------------------------------------------------------- # Pos # -----------------------------------------------------------------------------
[docs]class BasePos(tuple): """ A tuple subclass representing a (x, y) positions. Subclasses should override the __new__ method to enforce any necessary typing. """ __slots__ = () def __new__(cls, x, y): return super(BasePos, cls).__new__(cls, (x, y)) def __getnewargs__(self): return tuple(self) def __repr__(self): template = "%s(x=%s, y=%s)" values = (self.__class__.__name__,) + self return template % values @property def x(self): """ The 'x' component of the size. """ return self[0] @property def y(self): """ The 'y' component of the size. """ return self[1]
[docs]class Pos(BasePos): """ An implementation of BasePos for integer values. """ __slots__ = () def __new__(cls, x, y): i = int return super(Pos, cls).__new__(cls, i(x), i(y))
[docs]class PosF(BasePos): """ An implementation of BasePos of floating point values. """ __slots__ = () def __new__(cls, x, y): f = float return super(PosF, cls).__new__(cls, f(x), f(y))
# ----------------------------------------------------------------------------- # Size # -----------------------------------------------------------------------------
[docs]class BaseSize(tuple): """ A tuple subclass representing a (width, height) size. Subclasses should override the __new__ method to enforce any necessary typing. """ __slots__ = ()
[docs] @staticmethod def coerce_type(item): return item
def __new__(cls, width=None, height=None): if isinstance(width, (tuple, BaseSize)): return cls(*width) c = cls.coerce_type width = c(width) if height is None: height = width else: height = c(height) return super(BaseSize, cls).__new__(cls, (width, height)) def __getnewargs__(self): return tuple(self) def __repr__(self): template = "%s(width=%s, height=%s)" values = (self.__class__.__name__,) + self return template % values @property def width(self): """ The 'width' component of the size. """ return self[0] @property def height(self): """ The 'height' component of the size. """ return self[1]
[docs]class Size(BaseSize): """ A BaseSize implementation for integer values. """ __slots__ = ()
[docs] @staticmethod def coerce_type(item): return 0 if item is None else int(item)
[docs]class SizeF(BaseSize): """ A BaseSize implementation for floating point values. """ __slots__ = ()
[docs] @staticmethod def coerce_type(item): return 0.0 if item is None else float(item)