"""``miro.frontends.widgets.cellpack`` -- Code to layout
CustomTableCells.

We use the hbox/vbox model to lay things out with a couple changes.
The main difference here is that layouts are one-shot.  We don't keep
state around inside the cell renderers, so we just set up the objects
at the start, then use them to calculate info.
"""


class Margin(object):
    """Helper object used to calculate margins.
    """
    def __init__(self, margin):
        if margin is None:
            margin = (0, 0, 0, 0)
        self.margin_left = margin[3]
        self.margin_top = margin[0]
        self.margin_width = margin[1] + margin[3]
        self.margin_height = margin[0] + margin[2]

    def inner_rect(self, x, y, width, height):
        """Returns the x, y, width, height of the inner
        box.
        """
        return (x + self.margin_left,
                y + self.margin_top,
                width - self.margin_width,
                height - self.margin_height)

    def outer_size(self, inner_size):
        """Returns the width, height of the outer box.
        """
        return (inner_size[0] + self.margin_width,
                inner_size[1] + self.margin_height)

    def point_in_margin(self, x, y, width, height):
        """Returns whether a given point is inside of the
        margins.
        """
        return ((0 <= x - self.margin_left < width - self.margin_width) and
                (0 <= y - self.margin_top < height - self.margin_height))


class Packing(object):
    """Helper object used to layout Boxes.
    """
    def __init__(self, child, expand):
        self.child = child
        self.expand = expand

    def calc_size(self, translate_func):
        return translate_func(*self.child.get_size())

    def draw(self, context, x, y, width, height):
        self.child.draw(context, x, y, width, height)


class WhitespacePacking(object):
    """Helper object used to layout Boxes.
    """
    def __init__(self, size, expand):
        self.size = size
        self.expand = expand

    def calc_size(self, translate_func):
        return self.size, 0

    def draw(self, context, x, y, width, height):
        pass


class Packer(object):
    """Base class packing objects.  Packer objects work similarly to widgets,
    but they only used in custom cell renderers so there's a couple
    differences.  The main difference is that cell renderers don't keep state
    around.  Therefore Packers just get set up, used, then discarded.
    Also Packers can't receive events directly, so they have a different
    system to figure out where mouse clicks happened (the Hotspot class).
    """

    def render_layout(self, context):
        """position the child elements then call draw() on them."""
        self._layout(context, 0, 0, context.width, context.height)

    def draw(self, context, x, y, width, height):
        """Included so that Packer objects have a draw() method that matches
        ImageSurfaces, TextBoxes, etc.
        """
        self._layout(context, x, y, width, height)

    def _find_child_at(self, x, y, width, height):
        raise NotImplementedError()

    def get_size(self):
        """Get the minimum size required to hold the Packer.  """
        try:
            return self._size
        except AttributeError:
            self._size = self._calc_size()
            return self._size

    def get_current_size(self):
        """Get the minimum size required to hold the Packer at this point

        Call this method if you are going to change the packer after the call,
        for example if you have more children to pack into a box.  get_size()
        saves caches it's result which is can mess things up.
        """
        return self._calc_size()

    def find_hotspot(self, x, y, width, height):
        """Find the hotspot at (x, y).  width and height are the size of the
        cell this Packer is rendering.

        If a hotspot is found, return the tuple (name, x, y, width, height)
        where name is the name of the hotspot, x, y is the position relative
        to the top-left of the hotspot area and width, height are the
        dimensions of the hotspot.

        If no Hotspot is found return None.
        """
        child_pos = self._find_child_at(x, y, width, height)
        if child_pos:
            child, child_x, child_y, child_width, child_height = child_pos
            try:
                return child.find_hotspot(x - child_x, y - child_y,
                                          child_width, child_height)
            except AttributeError:
                pass  # child is a TextBox, Button or something like that
        return None

    def _layout(self, context, x, y, width, height):
        """Layout our children and call ``draw()`` on them.
        """
        raise NotImplementedError()

    def _calc_size(self):
        """Calculate the size needed to hold the box.  The return value gets
        cached and return in ``get_size()``.
        """
        raise NotImplementedError()


class Box(Packer):
    """Box is the base class for VBox and HBox.  Box objects lay out children
    linearly either left to right or top to bottom.
    """

    def __init__(self, spacing=0):
        """Create a new Box.  spacing is the amount of space to place
        in-between children.
        """
        self.spacing = spacing
        self.children = []
        self.children_end = []
        self.expand_count = 0

    def pack(self, child, expand=False):
        """Add a new child to the box.  The child will be placed after all the
        children packed before with pack_start.

        :param child: child to pack.  It can be anything with a
                      ``get_size()`` method, including TextBoxes,
                      ImageSurfarces, Buttons, Boxes and Backgrounds.
        :param expand: If True, then the child will enlarge if space
                       available is more than the space required.
        """
        if not (hasattr(child, 'draw') and hasattr(child, 'get_size')):
            raise TypeError("%s can't be drawn" % child)
        self.children.append(Packing(child, expand))
        if expand:
            self.expand_count += 1

    def pack_end(self, child, expand=False):
        """Add a new child to the end box.  The child will be placed before
        all the children packed before with pack_end.

        :param child: child to pack.  It can be anything with a
                      ``get_size()`` method, including TextBoxes,
                      ImageSurfarces, Buttons, Boxes and Backgrounds.
        :param expand: If True, then the child will enlarge if space
                       available is more than the space required.
        """
        if not (hasattr(child, 'draw') and hasattr(child, 'get_size')):
            raise TypeError("%s can't be drawn" % child)
        self.children_end.append(Packing(child, expand))
        if expand:
            self.expand_count += 1

    def pack_space(self, size, expand=False):
        """Pack whitespace into the box.
        """
        self.children.append(WhitespacePacking(size, expand))
        if expand:
            self.expand_count += 1

    def pack_space_end(self, size, expand=False):
        """Pack whitespace into the end of box.
        """
        self.children_end.append(WhitespacePacking(size, expand))
        if expand:
            self.expand_count += 1

    def _calc_size(self):
        length = 0
        breadth = 0
        for packing in self.children + self.children_end:
            child_length, child_breadth = packing.calc_size(self._translate)
            length += child_length
            breadth = max(breadth, child_breadth)
        total_children = len(self.children) + len(self.children_end)
        length += self.spacing * (total_children - 1)
        return self._translate(length, breadth)

    def _extra_space_iter(self, total_extra_space):
        """Generate the amount of extra space for children with expand set."""
        if total_extra_space <= 0:
            while True:
                yield 0
        (average_extra_space, leftover) = divmod(total_extra_space,
                                                 self.expand_count)
        while leftover > 1:
            # expand_count doesn't divide equally into total_extra_space,
            # yield average_extra_space+1 for each extra pixel
            yield average_extra_space + 1
            leftover -= 1
        # if there's a fraction of a pixel leftover, add that in
        yield average_extra_space + leftover
        while True:
            # no more leftover space
            yield average_extra_space

    def _position_children(self, total_length):
        my_length, my_breadth = self._translate(*self.get_size())
        extra_space_iter = self._extra_space_iter(total_length - my_length)

        pos = 0
        for packing in self.children:
            child_length, child_breadth = packing.calc_size(self._translate)
            if packing.expand:
                child_length += extra_space_iter.next()
            yield packing, pos, child_length
            pos += child_length + self.spacing

        pos = total_length
        for packing in self.children_end:
            child_length, child_breadth = packing.calc_size(self._translate)
            if packing.expand:
                child_length += extra_space_iter.next()
            pos -= child_length
            yield packing, pos, child_length
            pos -= self.spacing

    def _layout(self, context, x, y, width, height):
        total_length, total_breadth = self._translate(width, height)
        pos, offset = self._translate(x, y)
        position_iter = self._position_children(total_length)
        for packing, child_pos, child_length in position_iter:
            x, y = self._translate(pos + child_pos, offset)
            width, height = self._translate(child_length, total_breadth)
            packing.draw(context, x, y, width, height)

    def _find_child_at(self, x, y, width, height):
        total_length, total_breadth = self._translate(width, height)
        pos, offset = self._translate(x, y)
        position_iter = self._position_children(total_length)
        for packing, child_pos, child_length in position_iter:
            if child_pos <= pos < child_pos + child_length:
                x, y = self._translate(child_pos, 0)
                width, height = self._translate(child_length, total_breadth)
                if isinstance(packing, WhitespacePacking):
                    return None
                return packing.child, x, y, width, height
            elif child_pos > pos:
                break
        return None

    def _translate(self, x, y):
        """Translate (x, y) coordinates into (length, breadth) and
        vice-versa.
        """
        raise NotImplementedError()


class HBox(Box):
    def _translate(self, x, y):
        return x, y


class VBox(Box):
    def _translate(self, x, y):
        return y, x


class Table(Packer):
    def __init__(self, row_length=1, col_length=1,
                 row_spacing=0, col_spacing=0):
        """Create a new Table.

        :param row_length: how many rows long this should be
        :param col_length: how many rows wide this should be
        :param row_spacing: amount of spacing (in pixels) between rows
        :param col_spacing: amount of spacing (in pixels) between columns
        """
        assert min(row_length, col_length) > 0
        assert isinstance(row_length, int) and isinstance(col_length, int)
        self.row_length = row_length
        self.col_length = col_length
        self.row_spacing = row_spacing
        self.col_spacing = col_spacing
        self.table_multiarray = self._generate_table_multiarray()

    def _generate_table_multiarray(self):
        table_multiarray = []
        table_multiarray = [
            [None for col in range(self.col_length)]
            for row in range(self.row_length)]
        return table_multiarray

    def pack(self, child, row, column, expand=False):
        # TODO: flesh out "expand" ability, maybe?
        #
        # possibly throw a special exception if outside the range.
        # For now, just allowing an IndexError to be thrown.
        self.table_multiarray[row][column] = Packing(child, expand)

    def _get_grid_sizes(self):
        """Get the width and eights for both rows and columns
        """
        row_sizes = {}
        col_sizes = {}
        for row_count, row in enumerate(self.table_multiarray):
            row_sizes.setdefault(row_count, 0)
            for col_count, col_packing in enumerate(row):
                col_sizes.setdefault(col_count, 0)
                if col_packing:
                    x, y = col_packing.calc_size(self._translate)
                    if y > row_sizes[row_count]:
                        row_sizes[row_count] = y
                    if x > col_sizes[col_count]:
                        col_sizes[col_count] = x
        return col_sizes, row_sizes

    def _find_child_at(self, x, y, width, height):
        col_sizes, row_sizes = self._get_grid_sizes()
        row_distance = 0
        for row_count, row in enumerate(self.table_multiarray):
            col_distance = 0
            for col_count, packing in enumerate(row):
                child_width, child_height = packing.calc_size(self._translate)
                if packing.child:
                    if (col_distance <= x < col_distance + child_width and
                            row_distance <= y < row_distance + child_height):
                        return (packing.child,
                                col_distance, row_distance,
                                child_width, child_height)
                col_distance += col_sizes[col_count] + self.col_spacing
            row_distance += row_sizes[row_count] + self.row_spacing

    def _calc_size(self):
        col_sizes, row_sizes = self._get_grid_sizes()
        x = sum(col_sizes.values()) + (
            (self.col_length - 1) * self.col_spacing)
        y = sum(row_sizes.values()) + (
            (self.row_length - 1) * self.row_spacing)
        return x, y

    def _layout(self, context, x, y, width, height):
        col_sizes, row_sizes = self._get_grid_sizes()

        row_distance = 0
        for row_count, row in enumerate(self.table_multiarray):
            col_distance = 0
            for col_count, packing in enumerate(row):
                if packing:
                    child_width, child_height = packing.calc_size(
                        self._translate)
                    packing.child.draw(context,
                                       x + col_distance, y + row_distance,
                                       child_width, child_height)
                col_distance += col_sizes[col_count] + self.col_spacing
            row_distance += row_sizes[row_count] + self.row_spacing

    def _translate(self, x, y):
        return x, y


class Alignment(Packer):
    """Positions a child inside a larger space.
    """
    def __init__(self, child, xscale=1.0, yscale=1.0, xalign=0.0, yalign=0.0,
                 min_width=0, min_height=0):
        self.child = child
        self.xscale = xscale
        self.yscale = yscale
        self.xalign = xalign
        self.yalign = yalign
        self.min_width = min_width
        self.min_height = min_height

    def _calc_size(self):
        width, height = self.child.get_size()
        return max(self.min_width, width), max(self.min_height, height)

    def _calc_child_position(self, width, height):
        req_width, req_height = self.child.get_size()
        child_width = req_width + self.xscale * (width-req_width)
        child_height = req_height + self.yscale * (height-req_height)
        child_x = round(self.xalign * (width - child_width))
        child_y = round(self.yalign * (height - child_height))
        return child_x, child_y, child_width, child_height

    def _layout(self, context, x, y, width, height):
        child_x, child_y, child_width, child_height = \
                self._calc_child_position(width, height)
        self.child.draw(context, x + child_x, y + child_y, child_width,
                        child_height)

    def _find_child_at(self, x, y, width, height):
        child_x, child_y, child_width, child_height = \
                self._calc_child_position(width, height)
        if ((child_x <= x < child_x + child_width) and
                (child_y <= y < child_y + child_height)):
            return self.child, child_x, child_y, child_width, child_height
        else:
            return None  # (x, y) is in the empty space around child


class DrawingArea(Packer):
    """Area that uses custom drawing code.
    """
    def __init__(self, width, height, callback, *args):
        self.width = width
        self.height = height
        self.callback_info = (callback, args)

    def _calc_size(self):
        return self.width, self.height

    def _layout(self, context, x, y, width, height):
        callback, args = self.callback_info
        callback(context, x, y, width, height, *args)

    def _find_child_at(self, x, y, width, height):
        return None


class Background(Packer):
    """Draws a background behind a child element.
    """
    def __init__(self, child, min_width=0, min_height=0, margin=None):
        self.child = child
        self.min_width = min_width
        self.min_height = min_height
        self.margin = Margin(margin)
        self.callback_info = None

    def set_callback(self, callback, *args):
        self.callback_info = (callback, args)

    def _calc_size(self):
        width, height = self.child.get_size()
        width = max(self.min_width, width)
        height = max(self.min_height, height)
        return self.margin.outer_size((width, height))

    def _layout(self, context, x, y, width, height):
        if self.callback_info:
            callback, args = self.callback_info
            callback(context, x, y, width, height, *args)
        self.child.draw(context, *self.margin.inner_rect(x, y, width, height))

    def _find_child_at(self, x, y, width, height):
        if not self.margin.point_in_margin(x, y, width, height):
            return None
        return (self.child,) + self.margin.inner_rect(0, 0, width, height)


class Padding(Packer):
    """Adds padding to the edges of a packer.
    """
    def __init__(self, child, top=0, right=0, bottom=0, left=0):
        self.child = child
        self.margin = Margin((top, right, bottom, left))

    def _calc_size(self):
        return self.margin.outer_size(self.child.get_size())

    def _layout(self, context, x, y, width, height):
        self.child.draw(context, *self.margin.inner_rect(x, y, width, height))

    def _find_child_at(self, x, y, width, height):
        if not self.margin.point_in_margin(x, y, width, height):
            return None
        return (self.child,) + self.margin.inner_rect(0, 0, width, height)


class TextBoxPacker(Packer):
    """Base class for ClippedTextLine and ClippedTextBox.
    """
    def _layout(self, context, x, y, width, height):
        self.textbox.draw(context, x, y, width, height)

    def _find_child_at(self, x, y, width, height):
        # We could return the TextBox here, but we know it doesn't have a
        # find_hotspot() method
        return None


class ClippedTextBox(TextBoxPacker):
    """A TextBox that gets clipped if it's larger than it's allocated
    width.
    """
    def __init__(self, textbox, min_width=0, min_height=0):
        self.textbox = textbox
        self.min_width = min_width
        self.min_height = min_height

    def _calc_size(self):
        height = max(self.min_height, self.textbox.font.line_height())
        return self.min_width, height


class ClippedTextLine(TextBoxPacker):
    """A single line of text that gets clipped if it's larger than the
    space allocated to it.  By default the clipping will happen at character
    boundaries.
    """
    def __init__(self, textbox, min_width=0):
        self.textbox = textbox
        self.textbox.set_wrap_style('char')
        self.min_width = min_width

    def _calc_size(self):
        return self.min_width, self.textbox.font.line_height()


class TruncatedTextLine(ClippedTextLine):
    def __init__(self, textbox, min_width=0):
        ClippedTextLine.__init__(self, textbox, min_width)
        self.textbox.set_wrap_style('truncated-char')


class Hotspot(Packer):
    """A Hotspot handles mouse click tracking.  It's only purpose is
    to store a name to return from ``find_hotspot()``.  In terms of
    layout, it simply renders it's child in it's allocated space.
    """
    def __init__(self, name, child):
        self.name = name
        self.child = child

    def _calc_size(self):
        return self.child.get_size()

    def _layout(self, context, x, y, width, height):
        self.child.draw(context, x, y, width, height)

    def find_hotspot(self, x, y, width, height):
        return self.name, x, y, width, height


class Stack(Packer):
    """Packer that stacks other packers on top of each other.
    """
    def __init__(self):
        self.children = []

    def pack(self, packer):
        self.children.append(packer)

    def pack_below(self, packer):
        self.children.insert(0, packer)

    def _layout(self, context, x, y, width, height):
        for packer in self.children:
            packer._layout(context, x, y, width, height)

    def _calc_size(self):
        """Calculate the size needed to hold the box.  The return value gets
        cached and return in get_size().
        """
        width = height = 0
        for packer in self.children:
            child_width, child_height = packer.get_size()
            width = max(width, child_width)
            height = max(height, child_height)
        return width, height

    def _find_child_at(self, x, y, width, height):
        # Return the topmost packer
        try:
            top = self.children[-1]
        except IndexError:
            return None
        else:
            return top._find_child_at(x, y, width, height)


def align_left(packer):
    """Align a packer to the left side of it's allocated space."""
    return Alignment(packer, xalign=0.0, xscale=0.0)


def align_right(packer):
    """Align a packer to the right side of it's allocated space."""
    return Alignment(packer, xalign=1.0, xscale=0.0)


def align_top(packer):
    """Align a packer to the top side of it's allocated space."""
    return Alignment(packer, yalign=0.0, yscale=0.0)


def align_bottom(packer):
    """Align a packer to the bottom side of it's allocated space."""
    return Alignment(packer, yalign=1.0, yscale=0.0)


def align_middle(packer):
    """Align a packer to the middle of it's allocated space."""
    return Alignment(packer, yalign=0.5, yscale=0.0)


def align_center(packer):
    """Align a packer to the center of it's allocated space."""
    return Alignment(packer, xalign=0.5, xscale=0.0)


def pad(packer, top=0, left=0, bottom=0, right=0):
    """Add padding to a packer."""
    return Padding(packer, top, right, bottom, left)


class LayoutRect(object):
    """Lightweight object use to track rectangles inside a layout

    :attribute x: top coordinate, read-write
    :attribute y: left coordinate, read-write
    :attribute width: width of the rect, read-write
    :attribute height: height of the rect, read-write
    """

    def __init__(self, x, y, width, height):
        self.x = x
        self.y = y
        self.width = width
        self.height = height

    def __str__(self):
        return "LayoutRect(%s, %s, %s, %s)" % (self.x, self.y, self.width,
                                               self.height)

    def __eq__(self, other):
        my_values = (self.x, self.y, self.width, self.height)
        try:
            other_values = (other.x, other.y, other.width, other.height)
        except AttributeError:
            return NotImplemented
        return my_values == other_values

    def subsection(self, left, right, top, bottom):
        """Create a new LayoutRect from inside this one."""
        return LayoutRect(self.x + left, self.y + top,
                          self.width - left - right,
                          self.height - top - bottom)

    def right_side(self, width):
        """Create a new LayoutRect from the right side of this one."""
        return LayoutRect(self.right - width, self.y, width, self.height)

    def left_side(self, width):
        """Create a new LayoutRect from the left side of this one."""
        return LayoutRect(self.x, self.y, width, self.height)

    def top_side(self, height):
        """Create a new LayoutRect from the top side of this one."""
        return LayoutRect(self.x, self.y, self.width, height)

    def bottom_side(self, height):
        """Create a new LayoutRect from the bottom side of this one."""
        return LayoutRect(self.x, self.bottom - height, self.width, height)

    def past_right(self, width):
        """Create a LayoutRect width pixels to the right of this one>"""
        return LayoutRect(self.right, self.y, width, self.height)

    def past_left(self, width):
        """Create a LayoutRect width pixels to the right of this one>"""
        return LayoutRect(self.x-width, self.y, width, self.height)

    def past_top(self, height):
        """Create a LayoutRect height pixels above this one>"""
        return LayoutRect(self.x, self.y-height, self.width, height)

    def past_bottom(self, height):
        """Create a LayoutRect height pixels below this one>"""
        return LayoutRect(self.x, self.bottom, self.width, height)

    def is_point_inside(self, x, y):
        return (self.x <= x < self.x + self.width and
                self.y <= y < self.y + self.height)

    def get_right(self):
        return self.x + self.width

    def set_right(self, right):
        self.width = right - self.x
    right = property(get_right, set_right)

    def get_bottom(self):
        return self.y + self.height

    def set_bottom(self, bottom):
        self.height = bottom - self.y
    bottom = property(get_bottom, set_bottom)


class Layout(object):
    """Store the layout for a cell

    Layouts are lightweight objects that keep track of where stuff is inside a
    cell.  They can be used for both rendering and hotspot tracking.

    :attribute last_rect: the LayoutRect most recently added to the layout
    """

    def __init__(self):
        self._rects = []
        self.last_rect = None

    def rect_count(self):
        """Get the number of rects in this layout."""
        return len(self._rects)

    def add(self, x, y, width, height, drawing_function=None,
            hotspot=None):
        """Add a new element to this Layout

        :param x: x coordinate
        :param y: y coordinate
        :param width: width
        :param height: height
        :param drawing_function: if set, call this function to render the
                element on a DrawingContext
        :param hotspot: if set, the hotspot for this element

        :returns: LayoutRect of the added element
        """
        return self.add_rect(LayoutRect(x, y, width, height),
                             drawing_function, hotspot)

    def add_rect(self, layout_rect, drawing_function=None, hotspot=None):
        """Add a new element to this Layout using a LayoutRect

        :param layout_rect: LayoutRect object for positioning
        :param drawing_function: if set, call this function to render the
                element on a DrawingContext
        :param hotspot: if set, the hotspot for this element
        :returns: LayoutRect of the added element
        """
        self.last_rect = layout_rect
        value = (layout_rect, drawing_function, hotspot)
        self._rects.append(value)
        return layout_rect

    def add_text_line(self, textbox, x, y, width, hotspot=None):
        """Add one line of text from a text box to the layout

        This is convenience method that's equivelent to:
            self.add(x, y, width, textbox.font.line_height(), textbox.draw,
                    hotspot)
        """
        return self.add(x, y, width, textbox.font.line_height(), textbox.draw,
                        hotspot)

    def add_image(self, image, x, y, hotspot=None):
        """Add an ImageSurface to the layout

        This is convenience method that's equivelent to:
            self.add(x, y, image.width, image.height, image.draw, hotspot)
        """
        width, height = image.get_size()
        return self.add(x, y, width, height, image.draw, hotspot)

    def merge(self, layout):
        """Add another layout's elements with this one
        """
        self._rects.extend(layout._rects)
        self.last_rect = layout.last_rect

    def translate(self, delta_x, delta_y):
        """Move each element inside this layout """
        for rect, _, _ in self._rects:
            rect.x += delta_x
            rect.y += delta_y

    def max_width(self):
        """Get the max width of the elements in current group."""
        return max(rect.width for (rect, _, _) in self._rects)

    def max_height(self):
        """Get the max height of the elements in current group."""
        return max(rect.height for (rect, _, _) in self._rects)

    def center_x(self, left=None, right=None):
        """Center each rect inside this layout horizontally.

        The left and right arguments control the area to center the rects to.
        If one is missing, it will be calculated using largest width of the
        layout.  If both are missing, a ValueError will be thrown.

        :param left: left-side of the area to center to
        :param right: right-side of the area to center to
        """
        if left is None:
            if right is None:
                raise ValueError("both left and right are None")
            left = right - self.max_width()
        elif right is None:
            right = left + self.max_width()
        area_width = right - left
        for rect, _, _ in self._rects:
            rect.x = left + (area_width - rect.width) // 2

    def center_y(self, top=None, bottom=None):
        """Center each rect inside this layout vertically.

        The top and bottom arguments control the area to center the rects to.
        If one is missing, it will be calculated using largest height in the
        layout.  If both are missing, a ValueError will be thrown.

        :param top: top of the area to center to
        :param bottom: bottom of the area to center to
        """
        if top is None:
            if bottom is None:
                raise ValueError("both top and bottom are None")
            top = bottom - self.max_height()
        elif bottom is None:
            bottom = top + self.max_height()
        area_height = bottom - top
        for rect, _, _ in self._rects:
            rect.y = top + (area_height - rect.height) // 2

    def find_hotspot(self, x, y):
        """Find a hotspot inside our rects.

        If (x, y) is inside any of the rects for this layout and that rect has
        a hotspot set, a 3-tuple containing the hotspot name, and the x, y
        coordinates relative to the hotspot rect.  If no rect is found, we
        return None.

        :param x: x coordinate to check
        :param y: y coordinate to check
        """
        for rect, drawing_function, hotspot in self._rects:
            if hotspot is not None and rect.is_point_inside(x, y):
                return hotspot, x - rect.x, y - rect.y
        return None

    def draw(self, context):
        """Render each layout rect onto context

        :param context: a DrawingContext to draw on
        """

        for rect, drawing_function, hotspot in self._rects:
            if drawing_function is not None:
                drawing_function(context, rect.x, rect.y, rect.width,
                                 rect.height)