From 14738704ede6dfa6ac79f362a9c1f7f40f470cdc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jes=C3=BAs=20Eduardo?= Date: Mon, 11 Sep 2017 17:47:17 -0500 Subject: rename mvc at lvc --- mvc/widgets/cellpack.py | 843 ------------------------------------------------ 1 file changed, 843 deletions(-) delete mode 100644 mvc/widgets/cellpack.py (limited to 'mvc/widgets/cellpack.py') diff --git a/mvc/widgets/cellpack.py b/mvc/widgets/cellpack.py deleted file mode 100644 index 1347f56..0000000 --- a/mvc/widgets/cellpack.py +++ /dev/null @@ -1,843 +0,0 @@ -"""``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) -- cgit v1.2.3