def render(self, size, focus=False):
     fixed_size(size) # complain if parameter is wrong
     a = None
     ai = ak = 0
     o = []
     rows = self.font.height
     attrib = self.attrib+[(None,len(self.text))]
     for ch in self.text:
         if not ak:
             a, ak = attrib[ai]
             ai += 1
         ak -= 1
         width = self.font.char_width(ch)
         if not width: 
             # ignore invalid characters
             continue
         c = self.font.render(ch)
         if a is not None:
             c = CompositeCanvas(c)
             c.fill_attr(a)
         o.append((c, None, False, width))
     if o:
         canv = CanvasJoin(o)
     else:
         canv = TextCanvas([""]*rows, maxcol=0, 
             check_width=False)
         canv = CompositeCanvas(canv)
     canv.set_depends([])
     return canv

 def finalize_render(self, size, focus=False):
     canv = fn(self, size, focus=focus)
     if canv.widget_info:
         canv = CompositeCanvas(canv)
     validate_size(self, size, canv)
     canv.finalize(self, size, focus)
     return canv

 def render(self, size, focus=False):
     canv = self.__super.render(size, focus)
     if self._pop_up_widget:
         canv = CompositeCanvas(canv)
         canv.set_pop_up(self._pop_up_widget,
                         **self.get_pop_up_parameters())
     return canv

 def render(self, size, focus=False):
     """
     Render wrapped widget and apply attribute. Return canvas.
     """
     attr_map = self._attr_map
     if focus and self._focus_map is not None:
         attr_map = self._focus_map
     canv = self._original_widget.render(size, focus=focus)
     canv = CompositeCanvas(canv)
     canv.fill_attr_apply(attr_map)
     return canv

    def render(self, size, focus=False):
        """Render top_w overlayed on bottom_w."""
        left, right, top, bottom = self.calculate_padding_filler(size, focus)
        bottom_c = self.bottom_w.render(size)
        top_c = self.top_w.render(self.top_w_size(size, left, right, top, bottom), focus)
        top_c = CompositeCanvas(top_c)
        if left < 0 or right < 0:
            top_c.pad_trim_left_right(min(0, left), min(0, right))
        if top < 0 or bottom < 0:
            top_c.pad_trim_top_bottom(min(0, top), min(0, bottom))

        return CanvasOverlay(top_c, bottom_c, left, top)

    def cached_render(self, size, focus=False):
        focus = focus and not ignore_focus
        canv = CanvasCache.fetch(self, cls, size, focus)
        if canv:
            return canv

        canv = fn(self, size, focus=focus)
        validate_size(self, size, canv)
        if canv.widget_info:
            canv = CompositeCanvas(canv)
        canv.finalize(self, size, focus)
        CanvasCache.store(cls, canv)
        return canv

    def render(self, size, focus=False):
        """
        Render GraphVScale.
        """
        (maxcol, maxrow) = size
        pl = scale_bar_values(self.pos, self.top, maxrow)

        combinelist = []
        rows = 0
        for p, t in zip(pl, self.txt):
            p -= 1
            if p >= maxrow:
                break
            if p < rows:
                continue
            c = t.render((maxcol,))
            if p > rows:
                run = p - rows
                c = CompositeCanvas(c)
                c.pad_trim_top_bottom(run, 0)
            rows += c.rows()
            combinelist.append((c, None, False))
        if not combinelist:
            return SolidCanvas(" ", size[0], size[1])

        c = CanvasCombine(combinelist)
        if maxrow - rows:
            c.pad_trim_top_bottom(0, maxrow - rows)
        return c

    def render(self, size, focus=False):
        """
        Render the text content of this widget with a cursor when
        in focus.

        >>> si = SelectableIcon(u"[!]")
        >>> si
        <SelectableIcon selectable flow widget '[!]'>
        >>> si.render((4,), focus=True).cursor
        (1, 0)
        >>> si = SelectableIcon("((*))", 2)
        >>> si.render((8,), focus=True).cursor
        (2, 0)
        >>> si.render((2,), focus=True).cursor
        (0, 1)
        """
        c = self.__super.render(size, focus)
        if focus:
            # create a new canvas so we can add a cursor
            c = CompositeCanvas(c)
            c.cursor = self.get_cursor_coords(size)
        return c

    def render(self, size, focus=False):
        """
        Render edit widget and return canvas.  Include cursor when in
        focus.

        >>> c = Edit("? ","yes").render((10,), focus=True)
        >>> c.text # ... = b in Python 3
        [...'? yes     ']
        >>> c.cursor
        (5, 0)
        """
        (maxcol,) = size
        self._shift_view_to_cursor = bool(focus)

        canv = Text.render(self,(maxcol,))
        if focus:
            canv = CompositeCanvas(canv)
            canv.cursor = self.get_cursor_coords((maxcol,))

        # .. will need to FIXME if I want highlight to work again
        #if self.highlight:
        #    hstart, hstop = self.highlight_coords()
        #    d.coords['highlight'] = [ hstart, hstop ]
        return canv