def render(self, rect, data): x, y, w, h = rect.get_data() if self.top is not None: size = self.top.get_minimum_size(data) self.top.render(datatypes.Rectangle(x, y + h - size.y, w, size.y), data) h -= size.y + self.margin if self.bottom is not None: size = self.bottom.get_minimum_size(data) self.bottom.render(datatypes.Rectangle(x, y, w, size.y), data) y += size.y + self.margin h -= size.y + self.margin if self.right is not None: size = self.right.get_minimum_size(data) self.right.render( datatypes.Rectangle(x + w - size.x, y, size.x, h), data) w -= size.x + self.margin if self.left is not None: size = self.left.get_minimum_size(data) self.left.render(datatypes.Rectangle(x, y, size.x, h), data) w -= size.x + self.margin x += size.x + self.margin if self.center is not None: self.center.render(datatypes.Rectangle(x, y, w, h), data)
def render(self, rect, data): # Find the biggest rectangle of our original aspect ratio, # that we can fit in the given rectangle at our target angle. # First find the upscale we got going from our element to our # rotated minimum size. base_ms = self.element.get_minimum_size(data) rotated_ms = self._calculate_ms_from_base(base_ms) # Find the scale of the rect we're given and the limiting scale scale_x = rect.w / rotated_ms.x if rotated_ms.x > 0 else 999999999.0 scale_y = rect.h / rotated_ms.y if rotated_ms.y > 0 else 999999999.0 scale = min(scale_x, scale_y) # Transform the base size by this scale hw = base_ms.x * 0.5 * scale hh = base_ms.y * 0.5 * scale # Thats the space we give to our child element. center = rect.center_middle c = data['output'] with c: c.translate(center.x, center.y) c.rotate(self.angle / math.pi * 180.0) self.element.render( datatypes.Rectangle(-hw, -hh, hw * 2.0, hh * 2.0), data)
def render(self, rect, data): """Draws the managed element in the correct alignment.""" # We can't use our get minimum size, because that enforces # the size limits. size = self.element.get_minimum_size(data) # Assume we're top left at our natural size. x = rect.x y = rect.y w = size.x h = size.y extra_width = rect.w - w extra_height = rect.h - h if self.horizontal_align == AlignLM.ALIGN_CENTER: x += extra_width * 0.5 elif self.horizontal_align == AlignLM.ALIGN_RIGHT: x += extra_width elif self.horizontal_align == AlignLM.GROW_X: w = rect.w if self.vertical_align == AlignLM.ALIGN_MIDDLE: y += extra_height * 0.5 elif self.vertical_align == AlignLM.ALIGN_BOTTOM: y += extra_height elif self.vertical_align == AlignLM.GROW_Y: h = rect.h self.element.render(datatypes.Rectangle(x, y, w, h), data)
def render(self, rect, data): scale = self.scale c = data['output'] with c: c.translate(rect.x, rect.y) c.scale(scale, scale) self.element.render( datatypes.Rectangle(0, 0, rect.x / scale, rect.y / scale), data)
def render(self, rect, data): num_elements = len(self.elements) row_height = \ (rect.h-self.margin*(num_elements-1)) / float(num_elements) y = rect.y for element in reversed(self.elements): if element is not None: element.render( datatypes.Rectangle(rect.x, y, rect.w, row_height), data) y += row_height + self.margin
def render(self, rect, data): """Draws the columns.""" num_elements = len(self.elements) col_width = (rect.w - self.margin * (num_elements - 1)) / float(num_elements) x = rect.x for element in self.elements: if element is not None: element.render( datatypes.Rectangle(x, rect.y, col_width, rect.h), data) x += col_width + self.margin
def render(self, rect, data): # Use an if statement - it is much easier. x, y, w, h = rect.get_data() c = data['output'] with c: if self.angle == RotateLM.NORMAL: self.element.render(rect, data) else: c.translate(*rect.cm) c.rotate(self.angle * 90) if self.angle == RotateLM.ANGLE_180: self.element.render( datatypes.Rectangle(-w * 0.5, -h * 0.5, w, h), data) else: assert (self.angle in (RotateLM.ANGLE_90, RotateLM.ANGLE_270)) self.element.render( datatypes.Rectangle(-h * 0.5, -w * 0.5, h, w), data)
def render(self, rect, data): if self.element is None: return size = self.element.get_minimum_size(data) extra_width = max(0, rect.w - size.x) extra_height = max(0, rect.h - size.y) self.element.render( datatypes.Rectangle(rect.x + self._margins[3] * extra_width, rect.y + self._margins[2] * extra_height, rect.w - extra_width, rect.h - extra_height), data)
def _render_jittered( self, rectangle, data, angle_jitter, x_jitter, y_jitter ): c = data['output'] with c: c.translate(rectangle.center, rectangle.middle) c.translate(x_jitter, y_jitter) c.rotate(angle_jitter * 180.0 / math.pi) self.element.render( datatypes.Rectangle( -rectangle.w*0.5, -rectangle.h*0.5, rectangle.w, rectangle.h ), data )
def render(self, rect, data): size = self.element.get_minimum_size(data) if size.x > rect.w or size.y > rect.h: # The object is too big, work out the minimum scaling scale = min( float(rect.w) / float(size.x), float(rect.h) / float(size.y)) # Apply the scaling and render the output. c = data['output'] with c: c.translate(rect.x, rect.y) c.scale(scale, scale) self.element.render( datatypes.Rectangle(0, 0, rect.w / scale, rect.h / scale), data) else: self.element.render(rect, data)
def render(self, rect, data): size = self.element.get_minimum_size(data) # The object is too big, work out the minimum scaling scale = min(1, float(rect.w) / float(size.x), float(rect.h) / float(size.y)) extra_width = rect.w - size.x * scale extra_height = rect.h - size.y * scale # Apply the scaling and render the output. c = data['output'] with c: c.translate(rect.x + extra_width * 0.5, rect.y + extra_height * 0.5) if scale < 1.0: c.scale(scale, scale) self.element.render(datatypes.Rectangle(0, 0, size.x, size.y), data)
def render(self, rect, data): """ Displays the elements according to the align properties. """ # Make sure we're aligned correctly if self.horizontal_align not in VerticalLM._VALID_ALIGN_HORIZONTAL: raise ValueError('Horizontal align is not valid.') if self.vertical_align not in VerticalLM._VALID_ALIGN_VERTICAL: raise ValueError('Vertical align is not valid.') # Work out the extra height we have to distribute extra_height = rect.h - self.get_minimum_size(data).y num_elements = len(self.elements) if num_elements == 0: return elif num_elements > 1: per_margin = 1.0 / float(num_elements - 1) else: per_margin = 0.0 per_element = 1.0 / float(num_elements) # Work out the starting y coordinate y = rect.y if self.vertical_align == VerticalLM.ALIGN_MIDDLE: y = rect.y + extra_height * 0.5 elif self.vertical_align == VerticalLM.ALIGN_TOP: y = rect.y + extra_height # Render each child element for element in reversed(self.elements): size = element.get_minimum_size(data) # Work out the x-coordinates if self.horizontal_align == VerticalLM.ALIGN_LEFT: x = rect.x w = size.x elif self.horizontal_align == VerticalLM.ALIGN_CENTER: x = rect.center - size.x * 0.5 w = size.x elif self.horizontal_align == VerticalLM.ALIGN_RIGHT: x = rect.right - size.x w = size.x else: assert self.horizontal_align == VerticalLM.ALIGN_GROW x = rect.x w = rect.w # Work out the y-coordinates if self.vertical_align in VerticalLM._ALIGN_SIMPLE_SET: h = size.y next_y = y + size.y + self.margin elif self.vertical_align == VerticalLM.ALIGN_EQUAL_SPACING: h = size.y next_y = y + size.y + self.margin + extra_height * per_margin else: assert self.vertical_align == VerticalLM.ALIGN_EQUAL_GROWTH h = size.y + extra_height * per_element next_y = y + h + self.margin # Render and move on. element.render(datatypes.Rectangle(x, y, w, h), data) y = next_y
def render(self, rect, data): """Displays the elements according to the align properties.""" # Make sure we're aligned correctly if self.horizontal_align not in HorizontalLM._VALID_ALIGN_HORIZONTAL: raise ValueError('Horizontal align is not valid.') if self.vertical_align not in HorizontalLM._VALID_ALIGN_VERTICAL: raise ValueError('Vertical align is not valid.') # Work out the extra width we have to distribute extra_width = rect.w - self.get_minimum_size(data).x num_elements = len(self.elements) if num_elements == 0: return elif num_elements > 1: per_margin = 1.0 / float(num_elements - 1) else: per_margin = 0.0 per_element = 1.0 / float(num_elements) # Work out the starting x coordinate x = rect.x if self.horizontal_align == HorizontalLM.ALIGN_CENTER: x = rect.x + extra_width * 0.5 elif self.horizontal_align == HorizontalLM.ALIGN_RIGHT: x = rect.x + extra_width # Render each child element for element in self.elements: size = element.get_minimum_size(data) # Work out the y-coordinates if self.vertical_align == HorizontalLM.ALIGN_TOP: y = rect.top - size.y h = size.y elif self.vertical_align == HorizontalLM.ALIGN_MIDDLE: y = rect.middle - size.y * 0.5 h = size.y elif self.vertical_align == HorizontalLM.ALIGN_BOTTOM: y = rect.y h = size.y else: assert self.vertical_align == HorizontalLM.ALIGN_GROW y = rect.y h = rect.h # Work out the x-coordinates if self.horizontal_align in HorizontalLM._ALIGN_SIMPLE_SET: w = size.x next_x = x + size.x + self.margin elif self.horizontal_align == HorizontalLM.ALIGN_EQUAL_SPACING: w = size.x next_x = x + size.x + self.margin + extra_width * per_margin else: assert self.horizontal_align == HorizontalLM.ALIGN_EQUAL_GROWTH w = size.x + extra_width * per_element next_x = x + w + self.margin # Render and move on. element.render(datatypes.Rectangle(x, y, w, h), data) x = next_x
def render(self, rectangle, data): rect = datatypes.Rectangle( rectangle.x, rectangle.y, self.size.x, self.size.y ) self.element.render(rect, data)
def render(self, rect, data): self.element.render( datatypes.Rectangle(rect.x + rect.w * self.left, rect.y + rect.h * self.bottom, rect.w * (1.0 - self.left - self.right), rect.h * (1.0 - self.bottom - self.top)), data)
def render(self, rect, data): self.element.render( datatypes.Rectangle(rect.x + self.left, rect.y + self.bottom, rect.w - self.left - self.right, rect.h - self.bottom - self.top), data)