rename mvc at lvc

54 files changed, 16240 insertions, 0 deletions

diff --git a/lvc/widgets/__init__.py b/lvc/widgets/__init__.py
new file mode 100644
index 0000000..23a6edc
--- /dev/null
+++ b/lvc/widgets/__init__.py
@@ -0,0 +1,30 @@
+import logging
+import os
+import sys
+
+if sys.platform == 'darwin':
+    import osx as plat
+    from .osx import widgetset
+else:
+    import gtk as plat
+    from .gtk import widgetset
+
+attach_menubar = plat.attach_menubar
+mainloop_start = plat.mainloop_start
+mainloop_stop = plat.mainloop_stop
+idle_add = plat.idle_add
+idle_remove = plat.idle_remove
+reveal_file = plat.reveal_file
+get_conversion_directory = plat.get_conversion_directory
+
+def get_conversion_directory():
+    return os.path.join(plat.get_conversion_directory(), 'Libre Video Converter')
+    """directorio donde se guardan los videos convertidos"""
+
+def initialize(app):
+    try:
+        os.makedirs(get_conversion_directory())
+    except EnvironmentError, e:
+        logging.info('os.makedirs: %s', str(e))
+    if app:
+        plat.initialize(app)
diff --git a/lvc/widgets/app.py b/lvc/widgets/app.py
new file mode 100644
index 0000000..531b745
--- /dev/null
+++ b/lvc/widgets/app.py
@@ -0,0 +1,4 @@
+# app.py
+
+widgetapp = None
+
diff --git a/lvc/widgets/cellpack.py b/lvc/widgets/cellpack.py
new file mode 100644
index 0000000..1347f56
--- /dev/null
+++ b/lvc/widgets/cellpack.py
@@ -0,0 +1,843 @@
+"""``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)
diff --git a/lvc/widgets/dialogs.py b/lvc/widgets/dialogs.py
new file mode 100644
index 0000000..b6b2b70
--- /dev/null
+++ b/lvc/widgets/dialogs.py
@@ -0,0 +1,276 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""``miro.frontends.widgets.dialogs`` -- Dialog boxes for the Widget
+frontend.
+
+The difference between this module and rundialog.py is that rundialog
+handles dialog boxes that are coming from the backend code.  This
+model handles dialogs that we create from the frontend
+
+One big difference is that we don't have to be as general about
+dialogs, so they can present a somewhat nicer API.  One important
+difference is that all of the dialogs run modally.
+"""
+
+from lvc.widgets import widgetset
+from lvc.widgets import widgetutil
+
+class DialogButton(object):
+    def __init__(self, text):
+        self._text = text
+    def __eq__(self, other):
+        return isinstance(other, DialogButton) and self.text == other.text
+    def __str__(self):
+        return "DialogButton(%r)" % self.text
+    @property
+    def text(self):
+        return unicode(self._text)
+
+BUTTON_OK = DialogButton("OK")
+BUTTON_APPLY = DialogButton("Apply")
+BUTTON_CLOSE = DialogButton("Close")
+BUTTON_CANCEL = DialogButton("Cancel")
+BUTTON_DONE = DialogButton("Done")
+BUTTON_YES = DialogButton("Yes")
+BUTTON_NO = DialogButton("No")
+BUTTON_QUIT = DialogButton("Quit")
+BUTTON_CONTINUE = DialogButton("Continue")
+BUTTON_IGNORE = DialogButton("Ignore")
+BUTTON_IMPORT_FILES = DialogButton("Import Files")
+BUTTON_SUBMIT_REPORT = DialogButton("Submit Crash Report")
+BUTTON_MIGRATE = DialogButton("Migrate")
+BUTTON_DONT_MIGRATE = DialogButton("Don't Migrate")
+BUTTON_DOWNLOAD = DialogButton("Download")
+BUTTON_REMOVE_ENTRY = DialogButton("Remove Entry")
+BUTTON_DELETE_FILE = DialogButton("Delete File")
+BUTTON_DELETE_FILES = DialogButton("Delete Files")
+BUTTON_KEEP_VIDEOS = DialogButton("Keep Videos")
+BUTTON_DELETE_VIDEOS = DialogButton("Delete Videos")
+BUTTON_CREATE = DialogButton("Create")
+BUTTON_CREATE_FEED = DialogButton("Create Podcast")
+BUTTON_CREATE_FOLDER = DialogButton("Create Folder")
+BUTTON_CHOOSE_NEW_FOLDER = DialogButton("Choose New Folder")
+BUTTON_ADD_FOLDER = DialogButton("Add Folder")
+BUTTON_ADD = DialogButton("Add")
+BUTTON_ADD_INTO_NEW_FOLDER = DialogButton("Add Into New Folder")
+BUTTON_KEEP = DialogButton("Keep")
+BUTTON_DELETE = DialogButton("Delete")
+BUTTON_REMOVE = DialogButton("Remove")
+BUTTON_NOT_NOW = DialogButton("Not Now")
+BUTTON_CLOSE_TO_TRAY = DialogButton("Close to Tray")
+BUTTON_LAUNCH_MIRO = DialogButton("Launch Miro")
+BUTTON_DOWNLOAD_ANYWAY = DialogButton("Download Anyway")
+BUTTON_OPEN_IN_EXTERNAL_BROWSER = DialogButton(
+                                               "Open in External Browser")
+BUTTON_DONT_INSTALL = DialogButton("Don't Install")
+BUTTON_SUBSCRIBE = DialogButton("Subscribe")
+BUTTON_STOP_WATCHING = DialogButton("Stop Watching")
+BUTTON_RETRY = DialogButton("Retry")
+BUTTON_START_FRESH = DialogButton("Start Fresh")
+BUTTON_INCLUDE_DATABASE = DialogButton("Include Database")
+BUTTON_DONT_INCLUDE_DATABASE = DialogButton(
+                                            "Don't Include Database")
+
+WARNING_MESSAGE = 0
+INFO_MESSAGE = 1
+CRITICAL_MESSAGE = 2
+
+
+class ProgressDialog(widgetset.Dialog):
+    def __init__(self, title):
+        widgetset.Dialog.__init__(self, title, description='')
+        self.progress_bar = widgetset.ProgressBar()
+        self.label = widgetset.Label()
+        self.label.set_size(1.2)
+        self.vbox = widgetset.VBox(spacing=6)
+        self.vbox.pack_end(widgetutil.align_center(self.label))
+        self.vbox.pack_end(self.progress_bar)
+        self.set_extra_widget(self.vbox)
+
+    def update(self, description, progress):
+        self.label.set_text(description)
+        if progress >= 0:
+            self.progress_bar.set_progress(progress)
+            self.progress_bar.stop_pulsing()
+        else:
+            self.progress_bar.start_pulsing()
+
+class DBUpgradeProgressDialog(widgetset.Dialog):
+    def __init__(self, title, text):
+        widgetset.Dialog.__init__(self, title)
+        self.progress_bar = widgetset.ProgressBar()
+        self.top_label = widgetset.Label()
+        self.top_label.set_text(text)
+        self.top_label.set_wrap(True)
+        self.top_label.set_size_request(350, -1)
+        self.label = widgetset.Label()
+        self.vbox = widgetset.VBox(spacing=6)
+        self.vbox.pack_end(widgetutil.align_center(self.label))
+        self.vbox.pack_end(self.progress_bar)
+        self.vbox.pack_end(widgetutil.pad(self.top_label, bottom=6))
+        self.set_extra_widget(self.vbox)
+
+    def update(self, stage, stage_progress, progress):
+        self.label.set_text(stage)
+        self.progress_bar.set_progress(progress)
+
+def show_about():
+    window = widgetset.AboutDialog()
+    set_transient_for_main(window)
+    try:
+        window.run()
+    finally:
+        window.destroy()
+
+def show_message(title, description, alert_type=INFO_MESSAGE,
+        transient_for=None):
+    """Display a message to the user and wait for them to click OK"""
+    window = widgetset.AlertDialog(title, description, alert_type)
+    _set_transient_for(window, transient_for)
+    try:
+        window.add_button(BUTTON_OK.text)
+        window.run()
+    finally:
+        window.destroy()
+
+def show_choice_dialog(title, description, choices, transient_for=None):
+    """Display a message to the user and wait for them to choose an option.
+    Returns the button object chosen."""
+    window = widgetset.Dialog(title, description)
+    try:
+        for mem in choices:
+            window.add_button(mem.text)
+        response = window.run()
+        return choices[response]
+    finally:
+        window.destroy()
+
+def ask_for_string(title, description, initial_text=None, transient_for=None):
+    """Ask the user to enter a string in a TextEntry box.
+
+    description - textual description with newlines
+    initial_text - None, string or callable to pre-populate the entry box
+
+    Returns the value entered, or None if the user clicked cancel
+    """
+    window = widgetset.Dialog(title, description)
+    try:
+        window.add_button(BUTTON_OK.text)
+        window.add_button(BUTTON_CANCEL.text)
+        entry = widgetset.TextEntry()
+        entry.set_activates_default(True)
+        if initial_text:
+            if callable(initial_text):
+                initial_text = initial_text()
+            entry.set_text(initial_text)
+        window.set_extra_widget(entry)
+        response = window.run()
+        if response == 0:
+            return entry.get_text()
+        else:
+            return None
+    finally:
+        window.destroy()
+
+def ask_for_choice(title, description, choices):
+    """Ask the user to enter a string in a TextEntry box.
+
+    :param title: title for the window
+    :param description: textual description with newlines
+    :param choices: list of labels for choices
+    Returns the index of the value chosen, or None if the user clicked cancel
+    """
+    window = widgetset.Dialog(title, description)
+    try:
+        window.add_button(BUTTON_OK.text)
+        window.add_button(BUTTON_CANCEL.text)
+        menu = widgetset.OptionMenu(choices)
+        window.set_extra_widget(menu)
+        response = window.run()
+        if response == 0:
+            return menu.get_selected()
+        else:
+            return None
+    finally:
+        window.destroy()
+
+def ask_for_open_pathname(title, initial_filename=None, filters=[],
+        transient_for=None, select_multiple=False):
+    """Returns the file pathname or None.
+    """
+    window = widgetset.FileOpenDialog(title)
+    _set_transient_for(window, transient_for)
+    try:
+        if initial_filename:
+            window.set_filename(initial_filename)
+
+        if filters:
+            window.add_filters(filters)
+
+        if select_multiple:
+            window.set_select_multiple(select_multiple)
+
+        response = window.run()
+        if response == 0:
+            if select_multiple:
+                return window.get_filenames()
+            else:
+                return window.get_filename()
+    finally:
+        window.destroy()
+
+def ask_for_save_pathname(title, initial_filename=None, transient_for=None):
+    """Returns the file pathname or None.
+    """
+    window = widgetset.FileSaveDialog(title)
+    _set_transient_for(window, transient_for)
+    try:
+        if initial_filename:
+            window.set_filename(initial_filename)
+        response = window.run()
+        if response == 0:
+            return window.get_filename()
+    finally:
+        window.destroy()
+
+def ask_for_directory(title, initial_directory=None, transient_for=None):
+    """Returns the directory pathname or None.
+    """
+    window = widgetset.DirectorySelectDialog(title)
+    _set_transient_for(window, transient_for)
+    try:
+        if initial_directory:
+            window.set_directory(initial_directory)
+
+        response = window.run()
+        if response == 0:
+            return window.get_directory()
+    finally:
+        window.destroy()
diff --git a/lvc/widgets/gtk/__init__.py b/lvc/widgets/gtk/__init__.py
new file mode 100644
index 0000000..e3d666b
--- /dev/null
+++ b/lvc/widgets/gtk/__init__.py
@@ -0,0 +1,65 @@
+import os
+import sys
+import gtk
+import gobject
+
+def initialize(app):
+    from gtkmenus import MainWindowMenuBar
+    app.menubar = MainWindowMenuBar()
+    app.startup()
+    app.run()
+
+def attach_menubar():
+    from lvc.widgets import app
+    app.widgetapp.vbox.pack_start(app.widgetapp.menubar)
+
+def mainloop_start():
+    gobject.threads_init()
+    gtk.main()
+
+def mainloop_stop():
+    gtk.main_quit()
+
+def idle_add(callback, periodic=None):
+    if periodic is not None and periodic < 0:
+        raise ValueError('periodic cannot be negative')
+    def wrapper():
+        callback()
+        return periodic is not None
+    delay = periodic
+    if delay is not None:
+        delay *= 1000    # milliseconds
+    else:
+        delay = 0
+    return gobject.timeout_add(delay, wrapper)
+
+def idle_remove(id_):
+    gobject.source_remove(id_)
+
+def check_kde():
+    return os.environ.get("KDE_FULL_SESSION", None) != None
+
+def open_file_linux(filename):
+    if check_kde():
+        os.spawnlp(os.P_NOWAIT, "kfmclient", "kfmclient", # kfmclient is part of konqueror
+                   "exec", "file://" + filename)
+    else:
+        os.spawnlp(os.P_NOWAIT, "gnome-open", "gnome-open", filename)
+
+def reveal_file(filename):
+    if hasattr(os, 'startfile'): # Windows
+        os.startfile(os.path.dirname(filename))
+    else:
+        open_file_linux(filename)
+
+def get_conversion_directory_windows():
+    from lvc.windows import specialfolders
+    return specialfolders.base_movies_directory
+
+def get_conversion_directory_linux():
+    return os.path.expanduser('~')
+
+if sys.platform == 'win32':   
+    get_conversion_directory = get_conversion_directory_windows
+else:
+    get_conversion_directory = get_conversion_directory_linux
diff --git a/lvc/widgets/gtk/base.py b/lvc/widgets/gtk/base.py
new file mode 100644
index 0000000..ed6129f
--- /dev/null
+++ b/lvc/widgets/gtk/base.py
@@ -0,0 +1,300 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".base -- Base classes for GTK Widgets."""
+
+import gtk
+
+from lvc import signals
+import wrappermap
+from .weakconnect import weak_connect
+import keymap
+
+def make_gdk_color(miro_color):
+    def convert_value(value):
+        return int(round(value * 65535))
+
+    values = tuple(convert_value(c) for c in miro_color)
+    return gtk.gdk.Color(*values)
+
+class Widget(signals.SignalEmitter):
+    """Base class for GTK widgets.
+
+    The actual GTK Widget is stored in '_widget'.
+
+    signals:
+
+        'size-allocated' (widget, width, height): The widget had it's size
+            allocated.
+    """
+    def __init__(self, *signal_names):
+        signals.SignalEmitter.__init__(self, *signal_names)
+        self.create_signal('size-allocated')
+        self.create_signal('key-press')
+        self.create_signal('focus-out')
+        self.style_mods = {}
+        self.use_custom_style = False
+        self._disabled = False
+
+    def wrapped_widget_connect(self, signal, method, *user_args):
+        """Connect to a signal of the widget we're wrapping.
+
+        We use a weak reference to ensures that we don't have circular
+        references between the wrapped widget and the wrapper widget.
+        """
+        return weak_connect(self._widget, signal, method, *user_args)
+
+    def set_widget(self, widget):
+        self._widget = widget
+        wrappermap.add(self._widget, self)
+        if self.should_connect_to_hierarchy_changed():
+            self.wrapped_widget_connect('hierarchy_changed',
+                    self.on_hierarchy_changed)
+        self.wrapped_widget_connect('size-allocate', self.on_size_allocate)
+        self.wrapped_widget_connect('key-press-event', self.on_key_press)
+        self.wrapped_widget_connect('focus-out-event', self.on_focus_out)
+        self.use_custom_style_callback = None
+
+    def should_connect_to_hierarchy_changed(self):
+        # GTK creates windows to handle submenus, which messes with our
+        # on_hierarchy_changed callback.  We don't care about custom styles
+        # for menus anyways, so just ignore the signal.
+        return not isinstance(self._widget, gtk.MenuItem)
+
+    def set_can_focus(self, allow):
+        """Set if we allow the widget to hold keyboard focus.
+        """
+        if allow:
+            self._widget.set_flags(gtk.CAN_FOCUS)
+        else:
+            self._widget.unset_flags(gtk.CAN_FOCUS)
+
+    def on_hierarchy_changed(self, widget, previous_toplevel):
+        toplevel = widget.get_toplevel()
+        if not (toplevel.flags() & gtk.TOPLEVEL):
+            toplevel = None
+        if previous_toplevel != toplevel:
+            if self.use_custom_style_callback:
+                old_window = wrappermap.wrapper(previous_toplevel)
+                old_window.disconnect(self.use_custom_style_callback)
+            if toplevel is not None:
+                window = wrappermap.wrapper(toplevel)
+                callback_id = window.connect('use-custom-style-changed',
+                        self.on_use_custom_style_changed)
+                self.use_custom_style_callback = callback_id
+            else:
+                self.use_custom_style_callback = None
+            if previous_toplevel is None:
+                # Setup our initial state
+                self.on_use_custom_style_changed(window)
+
+    def on_size_allocate(self, widget, allocation):
+        self.emit('size-allocated', allocation.width, allocation.height)
+
+    def on_key_press(self, widget, event):
+        key_modifiers = keymap.translate_gtk_event(event)
+        if key_modifiers:
+            key, modifiers = key_modifiers
+            return self.emit('key-press', key, modifiers)
+
+    def on_focus_out(self, widget, event):
+        self.emit('focus-out')
+
+    def on_use_custom_style_changed(self, window):
+        self.use_custom_style = window.use_custom_style
+        if not self.style_mods:
+            return # no need to do any work here
+        if self.use_custom_style:
+            for (what, state), color in self.style_mods.items():
+                self.do_modify_style(what, state, color)
+        else:
+            # This should reset the style changes we've made
+            self._widget.modify_style(gtk.RcStyle())
+        self.handle_custom_style_change()
+
+    def handle_custom_style_change(self):
+        """Called when the user changes a from a theme where we don't want to
+        use our custom style to one where we do, or vice-versa.  The Widget
+        class handles changes that used modify_style(), but subclasses might
+        want to do additional work.
+        """
+        pass
+
+    def modify_style(self, what, state, color):
+        """Change the style of our widget.  This method checks to see if we
+        think the user's theme is compatible with our stylings, and doesn't
+        change things if not.  what is either 'base', 'text', 'bg' or 'fg'
+        depending on which color is to be changed.
+        """
+        if self.use_custom_style:
+            self.do_modify_style(what, state, color)
+        self.style_mods[(what, state)] = color
+
+    def unmodify_style(self, what, state):
+        if (what, state) in self.style_mods:
+            del self.style_mods[(what, state)]
+            default_color = getattr(self.style, what)[state]
+            self.do_modify_style(what, state, default_color)
+
+    def do_modify_style(self, what, state, color):
+        if what == 'base':
+            self._widget.modify_base(state, color)
+        elif what == 'text':
+            self._widget.modify_text(state, color)
+        elif what == 'bg':
+            self._widget.modify_bg(state, color)
+        elif what == 'fg':
+            self._widget.modify_fg(state, color)
+        else:
+            raise ValueError("Unknown what in do_modify_style: %s" % what)
+
+    def get_window(self):
+        gtk_window = self._widget.get_toplevel()
+        return wrappermap.wrapper(gtk_window)
+
+    def clear_size_request_cache(self):
+        # This is just an OS X hack
+        pass
+
+    def get_size_request(self):
+        return self._widget.size_request()
+
+    def invalidate_size_request(self):
+        self._widget.queue_resize()
+
+    def set_size_request(self, width, height):
+        if not width >= -1 and height >= -1:
+            raise ValueError("invalid dimensions in set_size_request: %s" %
+                            repr((width, height)))
+        self._widget.set_size_request(width, height)
+
+    def relative_position(self, other_widget):
+        return other_widget._widget.translate_coordinates(self._widget, 0, 0)
+
+    def convert_gtk_color(self, color):
+        return (color.red / 65535.0, color.green / 65535.0,
+                color.blue / 65535.0)
+
+    def get_width(self):
+        try:
+            return self._widget.allocation.width
+        except AttributeError:
+            return -1
+    width = property(get_width)
+
+    def get_height(self):
+        try:
+            return self._widget.allocation.height
+        except AttributeError:
+            return -1
+    height = property(get_height)
+
+    def queue_redraw(self):
+        if self._widget:
+            self._widget.queue_draw()
+
+    def redraw_now(self):
+        if self._widget:
+            self._widget.queue_draw()
+            self._widget.window.process_updates(True)
+
+    def forward_signal(self, signal_name, forwarded_signal_name=None):
+        """Add a callback so that when the GTK widget emits a signal, we emit
+        signal from the wrapper widget.
+        """
+        if forwarded_signal_name is None:
+            forwarded_signal_name = signal_name
+        self.wrapped_widget_connect(signal_name, self.do_forward_signal,
+                forwarded_signal_name)
+
+    def do_forward_signal(self, widget, *args):
+        forwarded_signal_name = args[-1]
+        args = args[:-1]
+        self.emit(forwarded_signal_name, *args)
+
+    def make_color(self, miro_color):
+        color = make_gdk_color(miro_color)
+        self._widget.get_colormap().alloc_color(color)
+        return color
+
+    def enable(self):
+        self._disabled = False
+        self._widget.set_sensitive(True)
+
+    def disable(self):
+        self._disabled = True
+        self._widget.set_sensitive(False)
+
+    def set_disabled(self, disabled):
+        if disabled:
+            self.disable()
+        else:
+            self.enable()
+
+    def get_disabled(self):
+        return self._disabled
+
+class Bin(Widget):
+    def __init__(self):
+        Widget.__init__(self)
+        self.child = None
+
+    def add(self, child):
+        if self.child is not None:
+            raise ValueError("Already have a child: %s" % self.child)
+        if child._widget.parent is not None:
+            raise ValueError("%s already has a parent" % child)
+        self.child = child
+        self.add_child_to_widget()
+        child._widget.show()
+
+    def add_child_to_widget(self):
+        self._widget.add(self.child._widget)
+
+    def remove_child_from_widget(self):
+        if self._widget.get_child() is not None:
+            # otherwise gtkmozembed gets confused
+            self._widget.get_child().hide()
+            self._widget.remove(self._widget.get_child())
+
+
+    def remove(self):
+        if self.child is not None:
+            self.child = None
+            self.remove_child_from_widget()
+
+    def set_child(self, new_child):
+        self.remove()
+        self.add(new_child)
+
+    def enable(self):
+        self.child.enable()
+
+    def disable(self):
+        self.child.disable()
diff --git a/lvc/widgets/gtk/const.py b/lvc/widgets/gtk/const.py
new file mode 100644
index 0000000..5e9ec05
--- /dev/null
+++ b/lvc/widgets/gtk/const.py
@@ -0,0 +1,44 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".const -- Constants."""
+
+import gtk
+
+DRAG_ACTION_NONE = 0
+DRAG_ACTION_COPY = gtk.gdk.ACTION_COPY
+DRAG_ACTION_MOVE = gtk.gdk.ACTION_MOVE
+DRAG_ACTION_LINK = gtk.gdk.ACTION_LINK
+DRAG_ACTION_ALL = DRAG_ACTION_COPY | DRAG_ACTION_MOVE | DRAG_ACTION_LINK
+
+ITEM_TITLE_FONT = "Helvetica"
+ITEM_DESC_FONT  = "Helvetica"
+ITEM_INFO_FONT  = "Lucida Grande"
+
+TOOLBAR_GRAY = (0.2, 0.2, 0.2)
diff --git a/lvc/widgets/gtk/contextmenu.py b/lvc/widgets/gtk/contextmenu.py
new file mode 100644
index 0000000..cd5b6ba
--- /dev/null
+++ b/lvc/widgets/gtk/contextmenu.py
@@ -0,0 +1,31 @@
+import gtk
+
+from .base import Widget
+
+class ContextMenu(Widget):
+
+    def __init__(self, options):
+        super(ContextMenu, self).__init__()
+        self.set_widget(gtk.Menu())
+        for i, item_info in enumerate(options):
+            if item_info is None:
+                # separator
+                item = gtk.SeparatorMenuItem()
+            else:
+                label, callback = item_info
+                item = gtk.MenuItem(label)
+                if isinstance(callback, list):
+                    submenu = ContextMenu(callback)
+                    item.set_submenu(submenu._widget)
+                elif callback is not None:
+                    item.connect('activate', self.on_activate, callback, i)
+                else:
+                    item.set_sensitive(False)
+            self._widget.append(item)
+            item.show()
+
+    def popup(self):
+        self._widget.popup(None, None, None, 0, 0)
+
+    def on_activate(self, widget, callback, i):
+        callback(self, i)
diff --git a/lvc/widgets/gtk/controls.py b/lvc/widgets/gtk/controls.py
new file mode 100644
index 0000000..26ce6d6
--- /dev/null
+++ b/lvc/widgets/gtk/controls.py
@@ -0,0 +1,337 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".controls -- Control Widgets."""
+
+import gtk
+import pango
+
+from lvc.widgets import widgetconst
+import layout
+from .base import Widget
+from .simple import Label
+
+class BinBaselineCalculator(object):
+    """Mixin class that defines the baseline method for gtk.Bin subclasses,
+    where the child is the label that we are trying to get the baseline for.
+    """
+
+    def baseline(self):
+        my_size = self._widget.size_request()
+        child_size = self._widget.child.size_request()
+        ypad = (my_size[1] - child_size[1]) / 2
+
+        pango_context = self._widget.get_pango_context()
+        metrics = pango_context.get_metrics(self._widget.style.font_desc)
+        return pango.PIXELS(metrics.get_descent()) + ypad
+
+class TextEntry(Widget):
+    entry_class = gtk.Entry
+    def __init__(self, initial_text=None):
+        Widget.__init__(self)
+        self.create_signal('activate')
+        self.create_signal('changed')
+        self.create_signal('validate')
+        self.set_widget(self.entry_class())
+        self.forward_signal('activate')
+        self.forward_signal('changed')
+        if initial_text is not None:
+            self.set_text(initial_text)
+
+    def focus(self):
+        self._widget.grab_focus()
+
+    def start_editing(self, text):
+        self.set_text(text)
+        self.focus()
+        self._widget.emit('move-cursor', gtk.MOVEMENT_BUFFER_ENDS, 1, False)
+
+    def set_text(self, text):
+        self._widget.set_text(text)
+
+    def get_text(self):
+        return self._widget.get_text().decode('utf-8')
+
+    def set_max_length(self, chars):
+        self._widget.set_max_length(chars)
+
+    def set_width(self, chars):
+        self._widget.set_width_chars(chars)
+
+    def set_invisible(self, setting):
+        self._widget.props.visibility = not setting
+
+    def set_activates_default(self, setting):
+        self._widget.set_activates_default(setting)
+
+    def baseline(self):
+        layout_height = pango.PIXELS(self._widget.get_layout().get_size()[1])
+        ypad = (self._widget.size_request()[1] - layout_height) / 2
+        pango_context = self._widget.get_pango_context()
+        metrics = pango_context.get_metrics(self._widget.style.font_desc)
+        return pango.PIXELS(metrics.get_descent()) + ypad
+
+
+class NumberEntry(TextEntry):
+    def __init__(self, initial_text=None):
+        TextEntry.__init__(self, initial_text)
+        self._widget.connect('changed', self.validate)
+        self.previous_text = initial_text or ""
+
+    def validate(self, entry):
+        text = self.get_text()
+        if text.isdigit() or not text:
+            self.previous_text = text
+        else:
+            self._widget.set_text(self.previous_text)
+
+class SecureTextEntry(TextEntry):
+    def __init__(self, initial_text=None):
+        TextEntry.__init__(self, initial_text)
+        self.set_invisible(True)
+
+class MultilineTextEntry(Widget):
+    entry_class = gtk.TextView
+    def __init__(self, initial_text=None, border=False):
+        Widget.__init__(self)
+        self.set_widget(self.entry_class())
+        if initial_text is not None:
+            self.set_text(initial_text)
+        self._widget.set_wrap_mode(gtk.WRAP_WORD)
+        self._widget.set_accepts_tab(False)
+        self.border = border
+
+    def focus(self):
+        self._widget.grab_focus()
+
+    def set_text(self, text):
+        self._widget.get_buffer().set_text(text)
+
+    def get_text(self):
+        buffer_ = self._widget.get_buffer()
+        return buffer_.get_text(*(buffer_.get_bounds())).decode('utf-8')
+
+    def baseline(self):
+        # FIXME
+        layout_height = pango.PIXELS(self._widget.get_layout().get_size()[1])
+        ypad = (self._widget.size_request()[1] - layout_height) / 2
+        pango_context = self._widget.get_pango_context()
+        metrics = pango_context.get_metrics(self._widget.style.font_desc)
+        return pango.PIXELS(metrics.get_descent()) + ypad
+
+    def set_editable(self, editable):
+        self._widget.set_editable(editable)
+
+class Checkbox(Widget, BinBaselineCalculator):
+    """Widget that the user can toggle on or off."""
+
+    def __init__(self, text=None, bold=False, color=None):
+        Widget.__init__(self)
+        BinBaselineCalculator.__init__(self)
+        if text is None:
+            text = ''
+        self.set_widget(gtk.CheckButton())
+        self.label = Label(text, color=color)
+        self._widget.add(self.label._widget)
+        self.label._widget.show()
+        self.create_signal('toggled')
+        self.forward_signal('toggled')
+        if bold:
+            self.label.set_bold(True)
+
+    def get_checked(self):
+        return self._widget.get_active()
+
+    def set_checked(self, value):
+        self._widget.set_active(value)
+
+    def set_size(self, scale_factor):
+        self.label.set_size(scale_factor)
+
+    def get_text_padding(self):
+        """
+        Returns the amount of space the checkbox takes up before the label.
+        """
+        indicator_size = self._widget.style_get_property('indicator-size')
+        indicator_spacing = self._widget.style_get_property(
+            'indicator-spacing')
+        focus_width = self._widget.style_get_property('focus-line-width')
+        focus_padding = self._widget.style_get_property('focus-padding')
+        return (indicator_size + 3 * indicator_spacing + 2 * (focus_width +
+                focus_padding))
+
+class RadioButtonGroup(Widget, BinBaselineCalculator):
+    """RadioButtonGroup.
+
+    Create the group, then create a bunch of RadioButtons passing in the group.
+
+    NB: GTK has built-in radio button grouping functionality, and we should
+    be using that but we need this widget for portable code.  We create
+    a dummy GTK radio button and make this the "root" button which gets
+    inherited by all buttons in this radio button group.
+    """
+    def __init__(self):
+        Widget.__init__(self)
+        BinBaselineCalculator.__init__(self)
+        self.set_widget(gtk.RadioButton(label=""))
+        self._widget.set_active(False)
+        self._buttons = []
+
+    def add_button(self, button):
+        self._buttons.append(button)
+
+    def get_buttons(self):
+        return self._buttons
+
+    def get_selected(self):
+        for mem in self._buttons:
+            if mem.get_selected():
+                return mem
+
+    def set_selected(self, button):
+        for mem in self._buttons:
+            if mem is button:
+                mem._widget.set_active(True)
+            else:
+                mem._widget.set_active(False)
+
+class RadioButton(Widget, BinBaselineCalculator):
+    """RadioButton."""
+    def __init__(self, label, group=None, color=None):
+        Widget.__init__(self)
+        BinBaselineCalculator.__init__(self)
+        if group:
+            self.group = group
+        else:
+            self.group = RadioButtonGroup()
+        self.set_widget(gtk.RadioButton(group=self.group._widget))
+        self.label = Label(label, color=color)
+        self._widget.add(self.label._widget)
+        self.label._widget.show()
+        self.create_signal('clicked')
+        self.forward_signal('clicked')
+
+        group.add_button(self)
+
+    def set_size(self, size):
+        self.label.set_size(size)
+
+    def get_group(self):
+        return self.group
+
+    def get_selected(self):
+        return self._widget.get_active()
+
+    def set_selected(self):
+        self.group.set_selected(self)
+
+class Button(Widget, BinBaselineCalculator):
+    def __init__(self, text, style='normal', width=None):
+        Widget.__init__(self)
+        BinBaselineCalculator.__init__(self)
+        # We just ignore style here, GTK users expect their own buttons.
+        self.set_widget(gtk.Button())
+        self.create_signal('clicked')
+        self.forward_signal('clicked')
+        self.label = Label(text)
+        # only honor width if its bigger than the width we need to display the
+        # label (#18994)
+        if width and width > self.label.get_width():
+            alignment = layout.Alignment(0.5, 0.5, 0, 0)
+            alignment.set_size_request(width, -1)
+            alignment.add(self.label)
+            self._widget.add(alignment._widget)
+        else:
+            self._widget.add(self.label._widget)
+        self.label._widget.show()
+
+    def set_text(self, title):
+        self.label.set_text(title)
+
+    def set_bold(self, bold):
+        self.label.set_bold(bold)
+
+    def set_size(self, scale_factor):
+        self.label.set_size(scale_factor)
+
+    def set_color(self, color):
+        self.label.set_color(color)
+
+class OptionMenu(Widget):
+    def __init__(self, options):
+        Widget.__init__(self)
+        self.create_signal('changed')
+
+        self.set_widget(gtk.ComboBox(gtk.ListStore(str, str)))
+        self.cell = gtk.CellRendererText()
+        self._widget.pack_start(self.cell, True)
+        self._widget.add_attribute(self.cell, 'text', 0)
+        if options:
+            for option, value in options:
+                self._widget.get_model().append((option, value))
+            self._widget.set_active(0)
+        self.options = options
+        self.wrapped_widget_connect('changed', self.on_changed)
+
+    def baseline(self):
+        my_size = self._widget.size_request()
+        child_size = self._widget.child.size_request()
+        ypad = self.cell.props.ypad + (my_size[1] - child_size[1]) / 2
+
+        pango_context = self._widget.get_pango_context()
+        metrics = pango_context.get_metrics(self._widget.style.font_desc)
+        return pango.PIXELS(metrics.get_descent()) + ypad
+
+    def set_bold(self, bold):
+        if bold:
+            self.cell.props.weight = pango.WEIGHT_BOLD
+        else:
+            self.cell.props.weight = pango.WEIGHT_NORMAL
+
+    def set_size(self, size):
+        if size == widgetconst.SIZE_NORMAL:
+            self.cell.props.scale = 1
+        else:
+            self.cell.props.scale = 0.75
+
+    def set_color(self, color):
+        self.cell.props.foreground_gdk = self.make_color(color)
+
+    def set_selected(self, index):
+        self._widget.set_active(index)
+
+    def get_selected(self):
+        return self._widget.get_active()
+
+    def on_changed(self, widget):
+        index = widget.get_active()
+        self.emit('changed', index)
+
+    def set_width(self, width):
+        self._widget.set_property('width-request', width)
diff --git a/lvc/widgets/gtk/customcontrols.py b/lvc/widgets/gtk/customcontrols.py
new file mode 100644
index 0000000..ff5b068
--- /dev/null
+++ b/lvc/widgets/gtk/customcontrols.py
@@ -0,0 +1,517 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".controls -- Contains the ControlBox and
+CustomControl classes.  These handle the custom buttons/sliders used during
+playback.
+"""
+
+from __future__ import division
+import math
+
+import gtk
+import gobject
+
+import wrappermap
+from .base import Widget
+from .simple import Label, Image
+from .drawing import (CustomDrawingMixin, Drawable,
+    ImageSurface)
+from lvc.widgets import widgetconst
+
+class CustomControlMixin(CustomDrawingMixin):
+    def do_expose_event(self, event):
+        CustomDrawingMixin.do_expose_event(self, event)
+        if self.is_focus():
+            style = self.get_style()
+            style.paint_focus(self.window, self.state,
+                    event.area, self, None, self.allocation.x,
+                    self.allocation.y, self.allocation.width,
+                    self.allocation.height)
+
+class CustomButtonWidget(CustomControlMixin, gtk.Button):
+    def draw(self, wrapper, context):
+        if self.is_active():
+            wrapper.state = 'pressed'
+        elif self.state == gtk.STATE_PRELIGHT:
+            wrapper.state = 'hover'
+        else:
+            wrapper.state = 'normal'
+        wrapper.draw(context, wrapper.layout_manager)
+        self.set_focus_on_click(False)
+
+    def is_active(self):
+        return self.state == gtk.STATE_ACTIVE
+
+class ContinuousCustomButtonWidget(CustomButtonWidget):
+    def is_active(self):
+        return (self.state == gtk.STATE_ACTIVE or
+                wrappermap.wrapper(self).button_down)
+
+class DragableCustomButtonWidget(CustomButtonWidget):
+    def __init__(self):
+        CustomButtonWidget.__init__(self)
+        self.button_press_x = None
+        self.set_events(self.get_events() | gtk.gdk.POINTER_MOTION_MASK)
+
+    def do_button_press_event(self, event):
+        self.button_press_x = event.x
+        self.last_drag_event = None
+        gtk.Button.do_button_press_event(self, event)
+
+    def do_button_release_event(self, event):
+        self.button_press_x = None
+        gtk.Button.do_button_release_event(self, event)
+
+    def do_motion_notify_event(self, event):
+        DRAG_THRESHOLD = 15
+        if self.button_press_x is None:
+            # button not down
+            return
+        if (self.last_drag_event != 'right' and
+                event.x > self.button_press_x + DRAG_THRESHOLD):
+            wrappermap.wrapper(self).emit('dragged-right')
+            self.last_drag_event = 'right'
+        elif (self.last_drag_event != 'left' and
+                event.x < self.button_press_x - DRAG_THRESHOLD):
+            wrappermap.wrapper(self).emit('dragged-left')
+            self.last_drag_event = 'left'
+
+    def do_clicked(self):
+        # only emit clicked if we didn't emit dragged-left or dragged-right
+        if self.last_drag_event is None:
+            wrappermap.wrapper(self).emit('clicked')
+
+class _DragInfo(object):
+    """Info about the start of a drag.
+
+    Attributes:
+
+    - button: button that started the drag
+    - start_pos: position of the slider
+    - click_pos: position of the click
+
+    Note that start_pos and click_pos will be different if the user clicks
+    inside the slider.
+    """
+
+    def __init__(self, button, start_pos, click_pos):
+        self.button = button
+        self.start_pos = start_pos
+        self.click_pos = click_pos
+
+class CustomScaleMixin(CustomControlMixin):
+    def __init__(self):
+        CustomControlMixin.__init__(self)
+        self.drag_info = None
+        self.min = self.max = 0.0
+
+    def get_range(self):
+        return self.min, self.max
+
+    def set_range(self, min, max):
+        self.min = float(min)
+        self.max = float(max)
+        gtk.Range.set_range(self, min, max)
+
+    def is_continuous(self):
+        return wrappermap.wrapper(self).is_continuous()
+
+    def is_horizontal(self):
+        # this comes from a mixin
+        pass
+
+    def gtk_scale_class(self):
+        if self.is_horizontal():
+            return gtk.HScale
+        else:
+            return gtk.VScale
+
+    def get_slider_pos(self, value=None):
+        if value is None:
+            value = self.get_value()
+        if self.is_horizontal():
+            size = self.allocation.width
+        else:
+            size = self.allocation.height
+        ratio = (float(value) - self.min) / (self.max - self.min)
+        start_pos = self.slider_size() / 2.0
+        return start_pos + ratio * (size - self.slider_size())
+
+    def slider_size(self):
+        return wrappermap.wrapper(self).slider_size()
+
+    def _event_pos(self, event):
+        """Get the position of an event.
+
+        If we are horizontal, this will be the x coordinate.  If we are
+        vertical, the y.
+        """
+        if self.is_horizontal():
+            return event.x
+        else:
+            return event.y
+
+    def do_button_press_event(self, event):
+        if self.drag_info is not None:
+            return
+        current_pos = self.get_slider_pos()
+        event_pos = self._event_pos(event)
+        pos_difference = abs(current_pos - event_pos)
+        # only move the slider if the click was outside its boundaries
+        # (#18840)
+        if pos_difference > self.slider_size() / 2.0:
+            self.move_slider(event_pos)
+            current_pos = event_pos
+        self.drag_info = _DragInfo(event.button, current_pos, event_pos)
+        self.grab_focus()
+        wrappermap.wrapper(self).emit('pressed')
+
+    def do_motion_notify_event(self, event):
+        if self.drag_info is not None:
+            event_pos = self._event_pos(event)
+            delta = event_pos - self.drag_info.click_pos
+            self.move_slider(self.drag_info.start_pos + delta)
+
+    def move_slider(self, new_pos):
+        """Move the slider so that it's centered on new_pos."""
+        if self.is_horizontal():
+            size = self.allocation.width
+        else:
+            size = self.allocation.height
+
+        slider_size = self.slider_size()
+        new_pos -= slider_size / 2
+        size -= slider_size
+        ratio = max(0, min(1, float(new_pos) / size))
+        self.set_value(ratio * (self.max - self.min))
+
+        wrappermap.wrapper(self).emit('moved', self.get_value())
+        if self.is_continuous():
+            wrappermap.wrapper(self).emit('changed', self.get_value())
+
+    def handle_drag_out_of_bounds(self):
+        if not self.is_continuous():
+            self.set_value(self.start_value)
+
+    def do_button_release_event(self, event):
+        if self.drag_info is None or event.button != self.drag_info.button:
+            return
+        self.drag_info = None
+        if (self.is_continuous and
+                (0 <= event.x < self.allocation.width) and
+                (0 <= event.y < self.allocation.height)):
+            wrappermap.wrapper(self).emit('changed', self.get_value())
+        wrappermap.wrapper(self).emit('released')
+
+    def do_scroll_event(self, event):
+        wrapper = wrappermap.wrapper(self)
+        if self.is_horizontal():
+            if event.direction == gtk.gdk.SCROLL_UP:
+                event.direction = gtk.gdk.SCROLL_DOWN
+            elif event.direction == gtk.gdk.SCROLL_DOWN:
+                event.direction = gtk.gdk.SCROLL_UP
+        if (wrapper._scroll_step is not None and
+            event.direction in (gtk.gdk.SCROLL_UP, gtk.gdk.SCROLL_DOWN)):
+            # handle the scroll ourself
+            if event.direction == gtk.gdk.SCROLL_DOWN:
+                delta = wrapper._scroll_step
+            else:
+                delta = -wrapper._scroll_step
+            self.set_value(self.get_value() + delta)
+        else:
+            # let GTK handle the scroll
+            self.gtk_scale_class().do_scroll_event(self, event)
+        # Treat mouse scrolls as if the user clicked on the new position
+        wrapper.emit('pressed')
+        wrapper.emit('changed', self.get_value())
+        wrapper.emit('released')
+
+    def do_move_slider(self, scroll):
+        if self.is_horizontal():
+            if scroll == gtk.SCROLL_STEP_UP:
+                scroll = gtk.SCROLL_STEP_DOWN
+            elif scroll == gtk.SCROLL_STEP_DOWN:
+                scroll = gtk.SCROLL_STEP_UP
+            elif scroll == gtk.SCROLL_PAGE_UP:
+                scroll = gtk.SCROLL_PAGE_DOWN
+            elif scroll == gtk.SCROLL_PAGE_DOWN:
+                scroll = gtk.SCROLL_PAGE_UP
+            elif scroll == gtk.SCROLL_START:
+                scroll = gtk.SCROLL_END
+            elif scroll == gtk.SCROLL_END:
+                scroll = gtk.SCROLL_START
+        return self.gtk_scale_class().do_move_slider(self, scroll)
+
+class CustomHScaleWidget(CustomScaleMixin, gtk.HScale):
+    def __init__(self):
+        CustomScaleMixin.__init__(self)
+        gtk.HScale.__init__(self)
+
+    def is_horizontal(self):
+        return True
+
+class CustomVScaleWidget(CustomScaleMixin, gtk.VScale):
+    def __init__(self):
+        CustomScaleMixin.__init__(self)
+        gtk.VScale.__init__(self)
+
+    def is_horizontal(self):
+        return False
+
+gobject.type_register(CustomButtonWidget)
+gobject.type_register(ContinuousCustomButtonWidget)
+gobject.type_register(DragableCustomButtonWidget)
+gobject.type_register(CustomHScaleWidget)
+gobject.type_register(CustomVScaleWidget)
+
+class CustomControlBase(Drawable, Widget):
+    def __init__(self):
+        Widget.__init__(self)
+        Drawable.__init__(self)
+        self._gtk_cursor = None
+        self._entry_handlers = None
+
+    def _connect_enter_notify_handlers(self):
+        if self._entry_handlers is None:
+            self._entry_handlers = [
+                    self.wrapped_widget_connect('enter-notify-event',
+                        self.on_enter_notify),
+                    self.wrapped_widget_connect('leave-notify-event',
+                        self.on_leave_notify),
+                    self.wrapped_widget_connect('button-release-event',
+                        self.on_click)
+            ]
+
+    def _disconnect_enter_notify_handlers(self):
+        if self._entry_handlers is not None:
+            for handle in self._entry_handlers:
+                self._widget.disconnect(handle)
+            self._entry_handlers = None
+
+    def set_cursor(self, cursor):
+        if cursor == widgetconst.CURSOR_NORMAL:
+            self._gtk_cursor = None
+            self._disconnect_enter_notify_handlers()
+        elif cursor == widgetconst.CURSOR_POINTING_HAND:
+            self._gtk_cursor = gtk.gdk.Cursor(gtk.gdk.HAND2)
+            self._connect_enter_notify_handlers()
+        else:
+            raise ValueError("Unknown cursor: %s" % cursor)
+
+    def on_enter_notify(self, widget, event):
+        self._widget.window.set_cursor(self._gtk_cursor)
+
+    def on_leave_notify(self, widget, event):
+        if self._widget.window:
+            self._widget.window.set_cursor(None)
+
+    def on_click(self, widget, event):
+        self.emit('clicked')
+        return True
+
+class CustomButton(CustomControlBase):
+    def __init__(self):
+        """Create a new CustomButton.  active_image will be displayed while
+        the button is pressed.  The image must have the same size.
+        """
+        CustomControlBase.__init__(self)
+        self.set_widget(CustomButtonWidget())
+        self.create_signal('clicked')
+        self.forward_signal('clicked')
+
+class DragableCustomButton(CustomControlBase):
+    def __init__(self):
+        CustomControlBase.__init__(self)
+        self.set_widget(DragableCustomButtonWidget())
+        self.create_signal('clicked')
+        self.create_signal('dragged-left')
+        self.create_signal('dragged-right')
+
+class CustomSlider(CustomControlBase):
+    def __init__(self):
+        CustomControlBase.__init__(self)
+        self.create_signal('pressed')
+        self.create_signal('released')
+        self.create_signal('changed')
+        self.create_signal('moved')
+        self._scroll_step = None
+        if self.is_horizontal():
+            self.set_widget(CustomHScaleWidget())
+        else:
+            self.set_widget(CustomVScaleWidget())
+        self.wrapped_widget_connect('move-slider', self.on_slider_move)
+
+    def on_slider_move(self, widget, scrolltype):
+        self.emit('changed', widget.get_value())
+        self.emit('moved', widget.get_value())
+
+    def get_value(self):
+        return self._widget.get_value()
+
+    def set_value(self, value):
+        self._widget.set_value(value)
+
+    def get_range(self):
+        return self._widget.get_range()
+
+    def get_slider_pos(self, value=None):
+        """Get the position for the slider for our current value.
+
+        This will return position that the slider should be centered on to
+        display the value.  It will be the x coordinate if is_horizontal() is
+        True and the y coordinate otherwise.
+
+        This method takes into acount the size of the slider when calculating
+        the position.  The slider position will start at (slider_size / 2) and
+        will end (slider_size / 2) px before the end of the widget.
+
+        :param value: value to get the position for.  Defaults to the current
+        value
+        """
+        return self._widget.get_slider_pos(value)
+
+    def set_range(self, min_value, max_value):
+        self._widget.set_range(min_value, max_value)
+        # set_digits controls the precision of the scale by limiting changes
+        # to a certain number of digits.  If the range is [0, 1], this code
+        # will give us 4 digits of precision, which seems reasonable.
+        range = max_value - min_value
+        self._widget.set_digits(int(round(math.log10(10000.0 / range))))
+
+    def set_increments(self, small_step, big_step, scroll_step=None):
+        """Set the increments to scroll.
+
+        :param small_step: scroll amount for up/down
+        :param big_step: scroll amount for page up/page down.
+        :param scroll_step: scroll amount for mouse wheel, or None to make
+                            this 2 times the small step
+        """
+        self._widget.set_increments(small_step, big_step)
+        self._scroll_step = scroll_step
+
+def to_miro_volume(value):
+    """Convert from 0 to 1.0 to 0.0 to MAX_VOLUME.
+    """
+    if value == 0:
+        return 0.0
+    return value * widgetconst.MAX_VOLUME
+
+def to_gtk_volume(value):
+    """Convert from 0.0 to MAX_VOLUME to 0 to 1.0.
+    """
+    if value > 0.0:
+        value = (value / widgetconst.MAX_VOLUME)
+    return value
+
+if hasattr(gtk.VolumeButton, "get_popup"):
+    # FIXME - Miro on Windows has an old version of gtk (2.16) and
+    # doesn't have the get_popup method.  Once we upgrade and
+    # fix that, we can take out the hasattr check.
+
+    class VolumeMuter(Label):
+        """Empty space that has a clicked signal so it can be dropped
+        in place of the VolumeMuter.
+        """
+        def __init__(self):
+            Label.__init__(self)
+            self.create_signal("clicked")
+
+    class VolumeSlider(Widget):
+        """VolumeSlider that uses the gtk.VolumeButton().
+        """
+        def __init__(self):
+            Widget.__init__(self)
+            self.set_widget(gtk.VolumeButton())
+            self.wrapped_widget_connect('value-changed', self.on_value_changed)
+            self._widget.get_popup().connect("hide", self.on_hide)
+            self.create_signal('changed')
+            self.create_signal('released')
+
+        def on_value_changed(self, *args):
+            value = self.get_value()
+            self.emit('changed', value)
+
+        def on_hide(self, *args):
+            self.emit('released')
+
+        def get_value(self):
+            value = self._widget.get_property('value')
+            return to_miro_volume(value)
+
+        def set_value(self, value):
+            value = to_gtk_volume(value)
+            self._widget.set_property('value', value)
+
+class ClickableImageButton(CustomButton):
+    """Image that can send clicked events. If max_width and/or max_height are
+    specified, resizes the image proportionally such that all constraints are
+    met.
+    """
+    def __init__(self, image_path, max_width=None, max_height=None):
+        CustomButton.__init__(self)
+        self.max_width = max_width
+        self.max_height = max_height
+        self.image = None
+        self._width, self._height = None, None
+        if image_path:
+            self.set_path(image_path)
+        self.set_cursor(widgetconst.CURSOR_POINTING_HAND)
+
+    def set_path(self, path):
+        image = Image(path)
+        if self.max_width:
+            image = image.resize_for_space(self.max_width, self.max_height)
+        self.image = ImageSurface(image)
+        self._width, self._height = image.width, image.height
+
+    def size_request(self, layout):
+        w = self._width
+        h = self._height
+        if not w:
+            w = self.max_width
+        if not h:
+            h = self.max_height
+        return w, h
+
+    def draw(self, context, layout):
+        if self.image:
+            self.image.draw(context, 0, 0, self._width, self._height)
+        w = self._width
+        h = self._height
+        if not w:
+            w = self.max_width
+        if not h:
+            h = self.max_height
+        w = min(context.width, w)
+        h = min(context.height, h)
+        context.rectangle(0, 0, w, h)
+        context.set_color((0, 0, 0))    # black
+        context.set_line_width(1)
+        context.stroke()
diff --git a/lvc/widgets/gtk/drawing.py b/lvc/widgets/gtk/drawing.py
new file mode 100644
index 0000000..5888851
--- /dev/null
+++ b/lvc/widgets/gtk/drawing.py
@@ -0,0 +1,268 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".drawing -- Contains classes used to draw on
+widgets.
+"""
+
+import cairo
+import gobject
+import gtk
+
+import wrappermap
+from .base import Widget, Bin
+from .layoutmanager import LayoutManager
+
+def css_to_color(css_string):
+    parts = (css_string[1:3], css_string[3:5], css_string[5:7])
+    return tuple((int(value, 16) / 255.0) for value in parts)
+
+class ImageSurface:
+    def __init__(self, image):
+        format = cairo.FORMAT_RGB24
+        if image.pixbuf.get_has_alpha():
+            format = cairo.FORMAT_ARGB32
+        self.image = cairo.ImageSurface(
+            format, int(image.width), int(image.height))
+        context = cairo.Context(self.image)
+        gdkcontext = gtk.gdk.CairoContext(context)
+        gdkcontext.set_source_pixbuf(image.pixbuf, 0, 0)
+        gdkcontext.paint()
+        self.pattern = cairo.SurfacePattern(self.image)
+        self.pattern.set_extend(cairo.EXTEND_REPEAT)
+        self.width = image.width
+        self.height = image.height
+
+    def get_size(self):
+        return self.width, self.height
+
+    def _align_pattern(self, x, y):
+        """Line up our image pattern so that it's top-left corner is x, y."""
+        m = cairo.Matrix()
+        m.translate(-x, -y)
+        self.pattern.set_matrix(m)
+
+    def draw(self, context, x, y, width, height, fraction=1.0):
+        self._align_pattern(x, y)
+        cairo_context = context.context
+        cairo_context.save()
+        cairo_context.set_source(self.pattern)
+        cairo_context.new_path()
+        cairo_context.rectangle(x, y, width, height)
+        if fraction >= 1.0:
+            cairo_context.fill()
+        else:
+            cairo_context.clip()
+            cairo_context.paint_with_alpha(fraction)
+        cairo_context.restore()
+
+    def draw_rect(self, context, dest_x, dest_y, source_x, source_y,
+            width, height, fraction=1.0):
+
+        self._align_pattern(dest_x-source_x, dest_y-source_y)
+        cairo_context = context.context
+        cairo_context.save()
+        cairo_context.set_source(self.pattern)
+        cairo_context.new_path()
+        cairo_context.rectangle(dest_x, dest_y, width, height)
+        if fraction >= 1.0:
+            cairo_context.fill()
+        else:
+            cairo_context.clip()
+            cairo_context.paint_with_alpha(fraction)
+        cairo_context.restore()
+
+class DrawingStyle(object):
+    def __init__(self, widget, use_base_color=False, state=None):
+        if state is None:
+            state = widget._widget.state
+        self.use_custom_style = widget.use_custom_style
+        self.style = widget._widget.style
+        self.text_color = widget.convert_gtk_color(self.style.text[state])
+        if use_base_color:
+            self.bg_color = widget.convert_gtk_color(self.style.base[state])
+        else:
+            self.bg_color = widget.convert_gtk_color(self.style.bg[state])
+
+class DrawingContext(object):
+    """DrawingContext.  This basically just wraps a Cairo context and adds a
+    couple convenience methods.
+    """
+
+    def __init__(self, window, drawing_area, expose_area):
+        self.window = window
+        self.context = window.cairo_create()
+        self.context.rectangle(expose_area.x, expose_area.y,
+                expose_area.width, expose_area.height)
+        self.context.clip()
+        self.width = drawing_area.width
+        self.height = drawing_area.height
+        self.context.translate(drawing_area.x, drawing_area.y)
+
+    def __getattr__(self, name):
+        return getattr(self.context, name)
+
+    def set_color(self, (red, green, blue), alpha=1.0):
+        self.context.set_source_rgba(red, green, blue, alpha)
+
+    def set_shadow(self, color, opacity, offset, blur_radius):
+        pass
+
+    def gradient_fill(self, gradient):
+        old_source = self.context.get_source()
+        self.context.set_source(gradient.pattern)
+        self.context.fill()
+        self.context.set_source(old_source)
+
+    def gradient_fill_preserve(self, gradient):
+        old_source = self.context.get_source()
+        self.context.set_source(gradient.pattern)
+        self.context.fill_preserve()
+        self.context.set_source(old_source)
+
+class Gradient(object):
+    def __init__(self, x1, y1, x2, y2):
+        self.pattern = cairo.LinearGradient(x1, y1, x2, y2)
+
+    def set_start_color(self, (red, green, blue)):
+        self.pattern.add_color_stop_rgb(0, red, green, blue)
+
+    def set_end_color(self, (red, green, blue)):
+        self.pattern.add_color_stop_rgb(1, red, green, blue)
+
+class CustomDrawingMixin(object):
+    def do_expose_event(self, event):
+        wrapper = wrappermap.wrapper(self)
+        if self.flags() & gtk.NO_WINDOW:
+            drawing_area = self.allocation
+        else:
+            drawing_area = gtk.gdk.Rectangle(0, 0,
+                    self.allocation.width, self.allocation.height)
+        context = DrawingContext(event.window, drawing_area, event.area)
+        context.style = DrawingStyle(wrapper)
+        if self.flags() & gtk.CAN_FOCUS:
+            focus_space = (self.style_get_property('focus-padding') +
+                    self.style_get_property('focus-line-width'))
+            if not wrapper.squish_width:
+                context.width -= focus_space * 2
+                translate_x = focus_space
+            else:
+                translate_x = 0
+            if not wrapper.squish_height:
+                context.height -= focus_space * 2
+                translate_y = focus_space
+            else:
+                translate_y = 0
+            context.translate(translate_x, translate_y)
+        wrapper.layout_manager.update_cairo_context(context.context)
+        self.draw(wrapper, context)
+
+    def draw(self, wrapper, context):
+        wrapper.layout_manager.reset()
+        wrapper.draw(context, wrapper.layout_manager)
+
+    def do_size_request(self, requesition):
+        wrapper = wrappermap.wrapper(self)
+        width, height = wrapper.size_request(wrapper.layout_manager)
+        requesition.width = width
+        requesition.height = height
+        if self.flags() & gtk.CAN_FOCUS:
+            focus_space = (self.style_get_property('focus-padding') +
+                    self.style_get_property('focus-line-width'))
+            if not wrapper.squish_width:
+                requesition.width += focus_space * 2
+            if not wrapper.squish_height:
+                requesition.height += focus_space * 2
+
+class MiroDrawingArea(CustomDrawingMixin, gtk.Widget):
+    def __init__(self):
+        gtk.Widget.__init__(self)
+        CustomDrawingMixin.__init__(self)
+        self.set_flags(gtk.NO_WINDOW)
+
+class BackgroundWidget(CustomDrawingMixin, gtk.Bin):
+    def do_size_request(self, requesition):
+        CustomDrawingMixin.do_size_request(self, requesition)
+        if self.get_child():
+            child_width, child_height = self.get_child().size_request()
+            requesition.width = max(child_width, requesition.width)
+            requesition.height = max(child_height, requesition.height)
+
+    def do_expose_event(self, event):
+        CustomDrawingMixin.do_expose_event(self, event)
+        if self.get_child():
+            self.propagate_expose(self.get_child(), event)
+
+    def do_size_allocate(self, allocation):
+        gtk.Bin.do_size_allocate(self, allocation)
+        if self.get_child():
+            self.get_child().size_allocate(allocation)
+
+gobject.type_register(MiroDrawingArea)
+gobject.type_register(BackgroundWidget)
+
+class Drawable:
+    def __init__(self):
+        self.squish_width = self.squish_height = False
+
+    def set_squish_width(self, setting):
+        self.squish_width = setting
+
+    def set_squish_height(self, setting):
+        self.squish_height = setting
+
+    def set_widget(self, drawing_widget):
+        if self.is_opaque() and 0:
+            box = gtk.EventBox()
+            box.add(drawing_widget)
+            Widget.set_widget(self, box)
+        else:
+            Widget.set_widget(self, drawing_widget)
+        self.layout_manager = LayoutManager(self._widget)
+
+    def size_request(self, layout_manager):
+        return 0, 0
+
+    def draw(self, context, layout_manager):
+        pass
+
+    def is_opaque(self):
+        return False
+
+class DrawingArea(Drawable, Widget):
+    def __init__(self):
+        Widget.__init__(self)
+        Drawable.__init__(self)
+        self.set_widget(MiroDrawingArea())
+
+class Background(Drawable, Bin):
+    def __init__(self):
+        Bin.__init__(self)
+        Drawable.__init__(self)
+        self.set_widget(BackgroundWidget())
diff --git a/lvc/widgets/gtk/gtkmenus.py b/lvc/widgets/gtk/gtkmenus.py
new file mode 100644
index 0000000..0e89fa8
--- /dev/null
+++ b/lvc/widgets/gtk/gtkmenus.py
@@ -0,0 +1,404 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""gtkmenus.py -- Manage menu layout."""
+
+import gtk
+
+from lvc.widgets import app
+
+import base
+import keymap
+import wrappermap
+
+def _setup_accel(widget, name, shortcut=None):
+    """Setup accelerators for a menu item.
+
+    This method sets an accel path for the widget and optionally connects a
+    shortcut to that accel path.
+    """
+    # The GTK docs say that we should set the path using this form:
+    # <Window-Name>/Menu/Submenu/MenuItem
+    # ...but this is hard to do because we don't yet know what window/menu
+    # this menu item is going to be added to.  gtk.Action and gtk.ActionGroup
+    # don't follow the above suggestion, so we don't need to either.
+    path = "<MiroActions>/MenuBar/%s" % name
+    widget.set_accel_path(path)
+    if shortcut is not None:
+        accel_string = keymap.get_accel_string(shortcut)
+        key, mods = gtk.accelerator_parse(accel_string)
+        if gtk.accel_map_lookup_entry(path) is None:
+            gtk.accel_map_add_entry(path, key, mods)
+        else:
+            gtk.accel_map_change_entry(path, key, mods, True)
+
+# map menu names to GTK stock ids.
+_STOCK_IDS = {
+    "SaveItem": gtk.STOCK_SAVE,
+    "CopyItemURL": gtk.STOCK_COPY,
+    "RemoveItems": gtk.STOCK_REMOVE,
+    "StopItem": gtk.STOCK_MEDIA_STOP,
+    "NextItem": gtk.STOCK_MEDIA_NEXT,
+    "PreviousItem": gtk.STOCK_MEDIA_PREVIOUS,
+    "PlayPauseItem": gtk.STOCK_MEDIA_PLAY,
+    "Open": gtk.STOCK_OPEN,
+    "EditPreferences": gtk.STOCK_PREFERENCES,
+    "Quit": gtk.STOCK_QUIT,
+    "Help": gtk.STOCK_HELP,
+    "About": gtk.STOCK_ABOUT,
+    "Translate": gtk.STOCK_EDIT
+}
+try:
+    _STOCK_IDS['Fullscreen'] = gtk.STOCK_FULLSCREEN
+except AttributeError:
+    # fullscreen not available on all GTK versions
+    pass
+
+class MenuItemBase(base.Widget):
+    """Base class for MenuItem and Separator."""
+
+    def show(self):
+        """Show this menu item."""
+        self._widget.show()
+
+    def hide(self):
+        """Hide and disable this menu item."""
+        self._widget.hide()
+
+    def remove_from_parent(self):
+        """Remove this menu item from it's parent Menu."""
+        parent_menu = self._widget.get_parent()
+        if parent_menu is None:
+            return
+        parent_menu_item = parent_menu.get_attach_widget()
+        if parent_menu_item is None:
+            return
+        parent_menu_item.remove(self._widget)
+
+    def _set_accel_group(self, accel_group):
+        # menu items don't care about the accel group, their parent Menu
+        # handles it for them
+        pass
+
+class MenuItem(MenuItemBase):
+    """Single item in the menu that can be clicked
+
+    :param label: The label it has (must be internationalized)
+    :param name: String identifier for this item
+    :param shortcut: Shortcut object to use
+
+    Signals:
+    - activate: menu item was clicked
+
+    Example:
+
+    >>> MenuItem(_("Preferences"), "EditPreferences")
+    >>> MenuItem(_("Cu_t"), "ClipboardCut", Shortcut("x", MOD))
+    >>> MenuItem(_("_Update Podcasts and Library"), "UpdatePodcasts",
+    ...          (Shortcut("r", MOD), Shortcut(F5)))
+    >>> MenuItem(_("_Play"), "PlayPauseItem",
+    ...          play=_("_Play"), pause=_("_Pause"))
+    """
+
+    def __init__(self, label, name, shortcut=None):
+        MenuItemBase.__init__(self)
+        self.name = name
+        self.set_widget(self.make_widget(label))
+        self.activate_id = self.wrapped_widget_connect('activate',
+                                                       self._on_activate)
+        self._widget.show()
+        self.create_signal('activate')
+        _setup_accel(self._widget, self.name, shortcut)
+
+    def _on_activate(self, menu_item):
+        self.emit('activate')
+        gtk_menubar = self._find_menubar()
+        if gtk_menubar is not None:
+            try:
+                menubar = wrappermap.wrapper(gtk_menubar)
+            except KeyError:
+                logging.exception('menubar activate: '
+                                  'no wrapper for gtbbk.MenuBar')
+            else:
+                menubar.emit('activate', self.name)
+
+    def _find_menubar(self):
+        """Find the MenuBar that this menu item is attached to."""
+        menu_item = self._widget
+        while True:
+            parent_menu = menu_item.get_parent()
+            if isinstance(parent_menu, gtk.MenuBar):
+                return parent_menu
+            elif parent_menu is None:
+                return None
+            menu_item = parent_menu.get_attach_widget()
+            if menu_item is None:
+                return None
+
+    def make_widget(self, label):
+        """Create the menu item to use for this widget.
+
+        Subclasses will probably want to override this.
+        """
+        if self.name in _STOCK_IDS:
+            mi = gtk.ImageMenuItem(stock_id=_STOCK_IDS[self.name])
+            mi.set_label(label)
+            return mi
+        else:
+            return gtk.MenuItem(label)
+
+    def set_label(self, new_label):
+        self._widget.set_label(new_label)
+
+    def get_label(self):
+        self._widget.get_label()
+
+class CheckMenuItem(MenuItem):
+    """MenuItem that toggles on/off"""
+
+    def make_widget(self, label):
+        return gtk.CheckMenuItem(label)
+
+    def set_state(self, active):
+        # prevent the activate signal from fireing in response to us manually
+        # changing a value
+        self._widget.handler_block(self.activate_id)
+        if active is not None:
+            self._widget.set_inconsistent(False)
+            self._widget.set_active(active)
+        else:
+            self._widget.set_inconsistent(True)
+            self._widget.set_active(False)
+        self._widget.handler_unblock(self.activate_id)
+
+    def get_state(self):
+        return self._widget.get_active()
+
+class RadioMenuItem(CheckMenuItem):
+    """MenuItem that toggles on/off and is grouped with other RadioMenuItems.
+    """
+
+    def make_widget(self, label):
+        widget = gtk.RadioMenuItem()
+        widget.set_label(label)
+        return widget
+
+    def set_group(self, group_item):
+        self._widget.set_group(group_item._widget)
+
+    def remove_from_group(self):
+        """Remove this RadioMenuItem from its current group."""
+        self._widget.set_group(None)
+
+    def _on_activate(self, menu_item):
+        # GTK sends the activate signal for both the radio button that's
+        # toggled on and the one that gets turned off.  Just emit our signal
+        # for the active radio button.
+        if self.get_state():
+            MenuItem._on_activate(self, menu_item)
+
+class Separator(MenuItemBase):
+    """Separator item for menus"""
+
+    def __init__(self):
+        MenuItemBase.__init__(self)
+        self.set_widget(gtk.SeparatorMenuItem())
+        self._widget.show()
+        # Set name to be None just so that it has a similar API to other menu
+        # items.
+        self.name = None
+
+class MenuShell(base.Widget):
+    """Common code shared between Menu and MenuBar.
+
+    Subclasses must define a _menu attribute that's a gtk.MenuShell subclass.
+    """
+
+    def __init__(self):
+        base.Widget.__init__(self)
+        self._accel_group = None
+        self.children = []
+
+    def append(self, menu_item):
+        """Add a menu item to the end of this menu."""
+        self.children.append(menu_item)
+        menu_item._set_accel_group(self._accel_group)
+        self._menu.append(menu_item._widget)
+
+    def insert(self, index, menu_item):
+        """Insert a menu item in the middle of this menu."""
+        self.children.insert(index, menu_item)
+        menu_item._set_accel_group(self._accel_group)
+        self._menu.insert(menu_item._widget, index)
+
+    def remove(self, menu_item):
+        """Remove a child menu item.
+
+        :raises ValueError: menu_item is not a child of this menu
+        """
+        self.children.remove(menu_item)
+        self._menu.remove(menu_item._widget)
+        menu_item._set_accel_group(None)
+
+    def index(self, name):
+        """Get the position of a menu item in this list.
+
+        :param name: name of the menu
+        :returns: index of the menu item, or -1 if not found.
+        """
+        for i, menu_item in enumerate(self.children):
+            if menu_item.name == name:
+                return i
+        return -1
+
+    def get_children(self):
+        """Get the child menu items in order."""
+        return list(self.children)
+
+    def find(self, name):
+        """Search for a menu or menu item
+
+        This method recursively searches the entire menu structure for a Menu
+        or MenuItem object with a given name.
+
+        :raises KeyError: name not found
+        """
+        found = self._find(name)
+        if found is None:
+            raise KeyError(name)
+        else:
+            return found
+
+    def _find(self, name):
+        """Low-level helper-method for find().
+
+        :returns: found menu item or None.
+        """
+        for menu_item in self.get_children():
+            if menu_item.name == name:
+                return menu_item
+            if isinstance(menu_item, MenuShell):
+                submenu_find = menu_item._find(name)
+                if submenu_find is not None:
+                    return submenu_find
+        return None
+
+class Menu(MenuShell):
+    """A Menu holds a list of MenuItems and Menus.
+
+    Example:
+    >>> Menu(_("P_layback"), "Playback", [
+    ...      MenuItem(_("_Foo"), "Foo"),
+    ...      MenuItem(_("_Bar"), "Bar")
+    ...      ])
+    >>> Menu("", "toplevel", [
+    ...     Menu(_("_File"), "File", [ ... ])
+    ...     ])
+    """
+
+    def __init__(self, label, name, child_items):
+        MenuShell.__init__(self)
+        self.set_widget(gtk.MenuItem(label))
+        self._widget.show()
+        self.name = name
+        # set up _menu for the MenuShell code
+        self._menu = gtk.Menu()
+        _setup_accel(self._menu, self.name)
+        self._widget.set_submenu(self._menu)
+        for item in child_items:
+            self.append(item)
+
+    def show(self):
+        """Show this menu."""
+        self._widget.show()
+
+    def hide(self):
+        """Hide this menu."""
+        self._widget.hide()
+
+    def _set_accel_group(self, accel_group):
+        """Set the accel group for this widget.
+
+        Accel groups get created by the MenuBar.  Whenever a menu or menu item
+        is added to that menu bar, the parent calls _set_accel_group() to give
+        the accel group to the child.
+        """
+        if accel_group == self._accel_group:
+            return
+        self._menu.set_accel_group(accel_group)
+        self._accel_group = accel_group
+        for child in self.children:
+            child._set_accel_group(accel_group)
+
+class MenuBar(MenuShell):
+    """Displays a list of Menu items.
+
+    Signals:
+
+    - activate(menu_bar, name): a menu item was activated
+    """
+
+    def __init__(self):
+        """Create a new MenuBar
+
+        :param name: string id to use for our action group
+        """
+        MenuShell.__init__(self)
+        self.create_signal('activate')
+        self.set_widget(gtk.MenuBar())
+        self._widget.show()
+        self._accel_group = gtk.AccelGroup()
+        # set up _menu for the MenuShell code
+        self._menu = self._widget
+
+    def get_accel_group(self):
+        return self._accel_group
+
+class MainWindowMenuBar(MenuBar):
+    """MenuBar for the main window.
+
+    This gets installed into app.widgetapp.menubar on GTK.
+    """
+    def add_initial_menus(self, menus):
+        """Add the initial set of menus.
+
+        We modify the menu structure slightly for GTK.
+        """
+        for menu in menus:
+            self.append(menu)
+        self._modify_initial_menus()
+
+    def _modify_initial_menus(self):
+        """Update the portable root menu with GTK-specific stuff."""
+        # on linux, we don't have a CheckVersion option because
+        # we update with the package system.
+        #this_platform = app.config.get(prefs.APP_PLATFORM)
+        #if this_platform == 'linux':
+        #    self.find("CheckVersion").remove_from_parent()
+        #app.video_renderer.setup_subtitle_encoding_menu()
diff --git a/lvc/widgets/gtk/keymap.py b/lvc/widgets/gtk/keymap.py
new file mode 100644
index 0000000..537525a
--- /dev/null
+++ b/lvc/widgets/gtk/keymap.py
@@ -0,0 +1,94 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""keymap.py -- Map portable key values to GTK ones.
+"""
+
+import gtk
+
+from lvc.widgets import keyboard
+
+menubar_mod_map = {
+    keyboard.MOD: '<Ctrl>',
+    keyboard.CTRL: '<Ctrl>',
+    keyboard.ALT: '<Alt>',
+    keyboard.SHIFT: '<Shift>',
+}
+
+menubar_key_map = {
+    keyboard.RIGHT_ARROW: 'Right',
+    keyboard.LEFT_ARROW: 'Left',
+    keyboard.UP_ARROW: 'Up',
+    keyboard.DOWN_ARROW: 'Down',
+    keyboard.SPACE: 'space',
+    keyboard.ENTER: 'Return',
+    keyboard.DELETE: 'Delete',
+    keyboard.BKSPACE: 'BackSpace',
+    keyboard.ESCAPE: 'Escape',
+    '>': 'greater',
+    '<': 'less'
+}
+for i in range(1, 13):
+    name = 'F%d' % i
+    menubar_key_map[getattr(keyboard, name)] = name
+
+# These are reversed versions of menubar_key_map and menubar_mod_map
+gtk_key_map = dict((i[1], i[0]) for i in menubar_key_map.items())
+
+def get_accel_string(shortcut):
+    mod_str = ''.join(menubar_mod_map[mod] for mod in shortcut.modifiers)
+    key_str = menubar_key_map.get(shortcut.shortcut, shortcut.shortcut)
+    return mod_str + key_str
+
+def translate_gtk_modifiers(event):
+    """Convert a keypress event to a set of modifiers from the shortcut
+    module.
+    """
+    modifiers = set()
+    if event.state & gtk.gdk.CONTROL_MASK:
+        modifiers.add(keyboard.CTRL)
+    if event.state & gtk.gdk.MOD1_MASK:
+        modifiers.add(keyboard.ALT)
+    if event.state & gtk.gdk.SHIFT_MASK:
+        modifiers.add(keyboard.SHIFT)
+    return modifiers
+
+def translate_gtk_event(event):
+    """Convert a GTK key event into the tuple (key, modifiers) where
+    key and modifiers are from the shortcut module.
+    """
+    gtk_keyval = gtk.gdk.keyval_name(event.keyval)
+    if gtk_keyval == None:
+        return None
+    if len(gtk_keyval) == 1:
+        key = gtk_keyval
+    else:
+        key = gtk_key_map.get(gtk_keyval)
+    modifiers = translate_gtk_modifiers(event)
+    return key, modifiers
diff --git a/lvc/widgets/gtk/layout.py b/lvc/widgets/gtk/layout.py
new file mode 100644
index 0000000..549311c
--- /dev/null
+++ b/lvc/widgets/gtk/layout.py
@@ -0,0 +1,227 @@
+# @Base:  Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".layout -- Layout widgets.  """
+
+import gtk
+
+from lvc.utils import Matrix
+from .base import Widget, Bin
+
+class Box(Widget):
+    def __init__(self, spacing=0):
+        Widget.__init__(self)
+        self.children = set()
+        self.set_widget(self.WIDGET_CLASS(spacing=spacing))
+
+    def pack_start(self, widget, expand=False, padding=0):
+        self._widget.pack_start(widget._widget, expand, fill=True,
+                padding=padding)
+        widget._widget.show()
+        self.children.add(widget)
+
+    def pack_end(self, widget, expand=False, padding=0):
+        self._widget.pack_end(widget._widget, expand, fill=True,
+                padding=padding)
+        widget._widget.show()
+        self.children.add(widget)
+
+    def remove(self, widget):
+        widget._widget.hide() # otherwise gtkmozembed gets confused
+        self._widget.remove(widget._widget)
+        self.children.remove(widget)
+
+    def enable(self):
+        for mem in self.children:
+            mem.enable()
+
+    def disable(self):
+        for mem in self.children:
+            mem.disable()
+
+class HBox(Box):
+    WIDGET_CLASS = gtk.HBox
+
+class VBox(Box):
+    WIDGET_CLASS = gtk.VBox
+
+class Alignment(Bin):
+    def __init__(self, xalign=0, yalign=0, xscale=0, yscale=0,
+            top_pad=0, bottom_pad=0, left_pad=0, right_pad=0):
+        Bin.__init__(self)
+        self.set_widget(gtk.Alignment(xalign, yalign, xscale, yscale))
+        self.set_padding(top_pad, bottom_pad, left_pad, right_pad)
+
+    def set(self, xalign=0, yalign=0, xscale=0, yscale=0):
+        self._widget.set(xalign, yalign, xscale, yscale)
+
+    def set_padding(self, top_pad=0, bottom_pad=0, left_pad=0, right_pad=0):
+        self._widget.set_padding(top_pad, bottom_pad, left_pad, right_pad)
+
+class DetachedWindowHolder(Alignment):
+    def __init__(self):
+        Alignment.__init__(self, xscale=1, yscale=1)
+
+class Splitter(Widget):
+    def __init__(self):
+        """Create a new splitter."""
+        Widget.__init__(self)
+        self.set_widget(gtk.HPaned())
+
+    def set_left(self, widget):
+        """Set the left child widget."""
+        self.left = widget
+        self._widget.pack1(widget._widget, resize=False, shrink=False)
+        widget._widget.show()
+
+    def set_right(self, widget):
+        """Set the right child widget.  """
+        self.right = widget
+        self._widget.pack2(widget._widget, resize=True, shrink=False)
+        widget._widget.show()
+
+    def remove_left(self):
+        """Remove the left child widget."""
+        if self.left is not None:
+            self.left._widget.hide() # otherwise gtkmozembed gets confused
+            self._widget.remove(self.left._widget)
+            self.left = None
+
+    def remove_right(self):
+        """Remove the right child widget."""
+        if self.right is not None:
+            self.right._widget.hide() # otherwise gtkmozembed gets confused
+            self._widget.remove(self.right._widget)
+            self.right = None
+
+    def set_left_width(self, width):
+        self._widget.set_position(width)
+
+    def get_left_width(self):
+        return self._widget.get_position()
+
+    def set_right_width(self, width):
+        self._widget.set_position(self.width - width)
+        # We should take into account the width of the bar, but this seems
+        # good enough.
+
+class Table(Widget):
+    """Lays out widgets in a table.  It works very similar to the GTK Table
+    widget, or an HTML table.
+    """
+    def __init__(self, columns, rows):
+        Widget.__init__(self)
+        self.set_widget(gtk.Table(rows, columns, homogeneous=False))
+        self.children = Matrix(columns, rows)
+
+    def pack(self, widget, column, row, column_span=1, row_span=1):
+        """Add a widget to the table.
+        """
+        self.children[column, row] = widget
+        self._widget.attach(widget._widget, column, column + column_span,
+                row, row + row_span)
+        widget._widget.show()
+
+    def remove(self, widget):
+        widget._widget.hide() # otherwise gtkmozembed gets confused
+        self.children.remove(widget)
+        self._widget.remove(widget._widget)
+
+    def set_column_spacing(self, spacing):
+        self._widget.set_col_spacings(spacing)
+
+    def set_row_spacing(self, spacing):
+        self._widget.set_row_spacings(spacing)
+
+    def enable(self, row=None, column=None):
+        if row != None and column != None:
+            if self.children[column, row]:
+                self.children[column, row].enable()
+        elif row != None:
+            for mem in self.children.row(row):
+                if mem: mem.enable()
+        elif column != None:
+            for mem in self.children.column(column):
+                if mem: mem.enable()
+        else:
+            for mem in self.children:
+                if mem: mem.enable()
+
+    def disable(self, row=None, column=None):
+        if row != None and column != None:
+            if self.children[column, row]:
+                self.children[column, row].disable()
+        elif row != None:
+            for mem in self.children.row(row):
+                if mem: mem.disable()
+        elif column != None:
+            for mem in self.children.column(column):
+                if mem: mem.disable()
+        else:
+            for mem in self.children:
+                if mem: mem.disable()
+
+class TabContainer(Widget):
+    def __init__(self, xalign=0, yalign=0, xscale=0, yscale=0,
+            top_pad=0, bottom_pad=0, left_pad=0, right_pad=0):
+        Widget.__init__(self)
+        self.set_widget(gtk.Notebook())
+        self._widget.set_tab_pos(gtk.POS_TOP)
+        self.children = []
+        self._page_to_select = None
+        self.wrapped_widget_connect('realize', self._on_realize)
+
+    def _on_realize(self, widget):
+        if self._page_to_select is not None:
+            self._widget.set_current_page(self._page_to_select)
+            self._page_to_select = None
+
+    def append_tab(self, child_widget, text, image=None):
+        if image is not None:
+            label_widget = gtk.VBox(spacing=2)
+            image_widget = gtk.Image()
+            image_widget.set_from_pixbuf(image.pixbuf)
+            label_widget.pack_start(image_widget)
+            label_widget.pack_start(gtk.Label(text))
+            label_widget.show_all()
+        else:
+            label_widget = gtk.Label(text)
+
+        # switch from a center align to a top align
+        child_widget.set(0, 0, 1, 0)
+        child_widget.set_padding(10, 10, 10, 10)
+
+        self._widget.append_page(child_widget._widget, label_widget)
+        self.children.append(child_widget)
+
+    def select_tab(self, index):
+        if self._widget.flags() & gtk.REALIZED:
+            self._widget.set_current_page(index)
+        else:
+            self._page_to_select = index
diff --git a/lvc/widgets/gtk/layoutmanager.py b/lvc/widgets/gtk/layoutmanager.py
new file mode 100644
index 0000000..8097b2e
--- /dev/null
+++ b/lvc/widgets/gtk/layoutmanager.py
@@ -0,0 +1,550 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""drawing.py -- Contains the LayoutManager class.  LayoutManager is
+handles laying out complex objects for the custom drawing code like
+text blocks and buttons.
+"""
+
+import math
+
+import cairo
+import gtk
+import pango
+
+from lvc import utils
+
+use_native_buttons = False # not implemented in MVC
+
+class FontCache(utils.Cache):
+    def get(self, context, description, scale_factor, bold, italic):
+        key = (context, description, scale_factor, bold, italic)
+        return utils.Cache.get(self, key)
+
+    def create_new_value(self, key, invalidator=None):
+        (context, description, scale_factor, bold, italic) = key
+        return Font(context, description, scale_factor, bold, italic)
+
+_font_cache = FontCache(512)
+
+class LayoutManager(object):
+    def __init__(self, widget):
+        self.pango_context = widget.get_pango_context()
+        self.update_style(widget.style)
+        self.update_direction(widget.get_direction())
+        widget.connect('style-set', self.on_style_set)
+        widget.connect('direction-changed', self.on_direction_changed)
+        self.widget = widget
+        self.reset()
+
+    def reset(self):
+        self.current_font = self.font(1.0)
+        self.text_color = (0, 0, 0)
+        self.text_shadow = None
+
+    def on_style_set(self, widget, previous_style):
+        old_font_desc = self.style_font_desc
+        self.update_style(widget.style)
+        if self.style_font_desc != old_font_desc:
+            # bug #17423 font changed, so the widget's width might have changed
+            widget.queue_resize()
+
+    def on_direction_changed(self, widget, previous_direction):
+        self.update_direction(widget.get_direction())
+
+    def update_style(self, style):
+        self.style_font_desc = style.font_desc
+        self.style = style
+
+    def update_direction(self, direction):
+        if direction == gtk.TEXT_DIR_RTL:
+            self.pango_context.set_base_dir(pango.DIRECTION_RTL)
+        else:
+            self.pango_context.set_base_dir(pango.DIRECTION_LTR)
+
+    def font(self, scale_factor, bold=False, italic=False, family=None):
+        return _font_cache.get(self.pango_context, self.style_font_desc,
+                scale_factor, bold, italic)
+
+    def set_font(self, scale_factor, bold=False, italic=False, family=None):
+        self.current_font = self.font(scale_factor, bold, italic)
+
+    def set_text_color(self, color):
+        self.text_color = color
+
+    def set_text_shadow(self, shadow):
+        self.text_shadow = shadow
+
+    def textbox(self, text, underline=False):
+        textbox = TextBox(self.pango_context, self.current_font,
+                self.text_color, self.text_shadow)
+        textbox.set_text(text, underline=underline)
+        return textbox
+
+    def button(self, text, pressed=False, disabled=False, style='normal'):
+        if style == 'webby':
+            return StyledButton(text, self.pango_context, self.current_font,
+                    pressed, disabled)
+        elif use_native_buttons:
+            return NativeButton(text, self.pango_context, self.current_font,
+                    pressed, self.style, self.widget)
+        else:
+            return StyledButton(text, self.pango_context, self.current_font,
+                    pressed)
+
+    def update_cairo_context(self, cairo_context):
+        cairo_context.update_context(self.pango_context)
+
+class Font(object):
+    def __init__(self, context, style_font_desc, scale, bold, italic):
+        self.context = context
+        self.description = style_font_desc.copy()
+        self.description.set_size(int(scale * style_font_desc.get_size()))
+        if bold:
+            self.description.set_weight(pango.WEIGHT_BOLD)
+        if italic:
+            self.description.set_style(pango.STYLE_ITALIC)
+        self.font_metrics = None
+
+    def get_font_metrics(self):
+        if self.font_metrics is None:
+            self.font_metrics = self.context.get_metrics(self.description)
+        return self.font_metrics
+
+    def ascent(self):
+        return pango.PIXELS(self.get_font_metrics().get_ascent())
+
+    def descent(self):
+        return pango.PIXELS(self.get_font_metrics().get_descent())
+
+    def line_height(self):
+        metrics = self.get_font_metrics()
+        # the +1: some glyphs can be slightly taller than ascent+descent
+        # (#17329)
+        return (pango.PIXELS(metrics.get_ascent()) +
+                pango.PIXELS(metrics.get_descent()) + 1)
+
+class TextBox(object):
+    def __init__(self, context, font, color, shadow):
+        self.layout = pango.Layout(context)
+        self.layout.set_wrap(pango.WRAP_WORD_CHAR)
+        self.font = font
+        self.color = color
+        self.layout.set_font_description(font.description.copy())
+        self.width = self.height = None
+        self.shadow = shadow
+
+    def set_text(self, text, font=None, color=None, underline=False):
+        self.text_chunks = []
+        self.attributes = []
+        self.text_length = 0
+        self.underlines = []
+        self.append_text(text, font, color, underline)
+
+    def append_text(self, text, font=None, color=None, underline=False):
+        if text == None:
+            text = u""
+        startpos = self.text_length
+        self.text_chunks.append(text)
+        endpos = self.text_length = self.text_length + len(text)
+        if font is not None:
+            attr = pango.AttrFontDesc(font.description, startpos, endpos)
+            self.attributes.append(attr)
+        if underline:
+            self.underlines.append((startpos, endpos))
+        if color:
+            def convert(value):
+                return int(round(value * 65535))
+            attr = pango.AttrForeground(convert(color[0]), convert(color[1]),
+                    convert(color[2]), startpos, endpos)
+            self.attributes.append(attr)
+        self.text_set = False
+
+    def set_width(self, width):
+        if width is not None:
+            self.layout.set_width(int(width * pango.SCALE))
+        else:
+            self.layout.set_width(-1)
+        self.width = width
+
+    def set_height(self, height):
+        # if height is not None:
+        #     # not sure why set_height isn't in the python bindings, but it
+        #     # isn't
+        #     pygtkhacks.set_pango_layout_height(self.layout,
+        #         int(height * pango.SCALE))
+        self.height = height
+
+    def set_wrap_style(self, wrap):
+        if wrap == 'word':
+            self.layout.set_wrap(pango.WRAP_WORD_CHAR)
+        elif wrap == 'char' or wrap == 'truncated-char':
+            self.layout.set_wrap(pango.WRAP_CHAR)
+        else:
+            raise ValueError("Unknown wrap value: %s" % wrap)
+        if wrap == 'truncated-char':
+            self.layout.set_ellipsize(pango.ELLIPSIZE_END)
+        else:
+            self.layout.set_ellipsize(pango.ELLIPSIZE_NONE)
+
+    def set_alignment(self, align):
+        if align == 'left':
+            self.layout.set_alignment(pango.ALIGN_LEFT)
+        elif align == 'right':
+            self.layout.set_alignment(pango.ALIGN_RIGHT)
+        elif align == 'center':
+            self.layout.set_alignment(pango.ALIGN_CENTER)
+        else:
+            raise ValueError("Unknown align value: %s" % align)
+
+    def ensure_layout(self):
+        if not self.text_set:
+            text = ''.join(self.text_chunks)
+            if len(text) > 100:
+                text = text[:self._calc_text_cutoff()]
+            self.layout.set_text(text)
+            attr_list = pango.AttrList()
+            for attr in self.attributes:
+                attr_list.insert(attr)
+            self.layout.set_attributes(attr_list)
+            self.text_set = True
+
+    def _calc_text_cutoff(self):
+        """This method is a bit of a hack...  GTK slows down if we pass too
+        much text to the layout.  Even text that falls below our height has a
+        performance penalty.  Try not to have too much more than is necessary.
+        """
+        if None in (self.width, self.height):
+            return -1
+
+        chars_per_line = (self.width * pango.SCALE //
+                self.font.get_font_metrics().get_approximate_char_width())
+        lines_available = self.height // self.font.line_height()
+        # overestimate these because it's better to have too many characters
+        # than too little.
+        return int(chars_per_line * lines_available * 1.2)
+
+    def line_count(self):
+        self.ensure_layout()
+        return self.layout.get_line_count()
+
+    def get_size(self):
+        self.ensure_layout()
+        return self.layout.get_pixel_size()
+
+    def char_at(self, x, y):
+        self.ensure_layout()
+        x *= pango.SCALE
+        y *= pango.SCALE
+        width, height = self.layout.get_size()
+        if 0 <= x < width and 0 <= y < height:
+            index, leading = self.layout.xy_to_index(x, y)
+            # xy_to_index returns the nearest character, but that
+            # doesn't mean the user actually clicked on it.  Double
+            # check that (x, y) is actually inside that char's
+            # bounding box
+            char_x, char_y, char_w, char_h = self.layout.index_to_pos(index)
+            if char_w > 0: # the glyph is LTR
+                left = char_x
+                right = char_x + char_w
+            else: # the glyph is RTL
+                left = char_x + char_w
+                right = char_x
+            if left <= x < right:
+                return index
+        return None
+
+
+    def draw(self, context, x, y, width, height):
+        self.set_width(width)
+        self.set_height(height)
+        self.ensure_layout()
+        cairo_context = context.context
+        cairo_context.save()
+        underline_drawer = UnderlineDrawer(self.underlines)
+        if self.shadow:
+            # draw shadow first so that it's underneath the regular text
+            # FIXME: we don't use the blur_radius setting
+            cairo_context.set_source_rgba(self.shadow.color[0],
+                    self.shadow.color[1], self.shadow.color[2],
+                    self.shadow.opacity)
+            self._draw_layout(context, x + self.shadow.offset[0],
+                    y + self.shadow.offset[1], width, height,
+                    underline_drawer)
+        cairo_context.set_source_rgb(*self.color)
+        self._draw_layout(context, x, y, width, height, underline_drawer)
+        cairo_context.restore()
+        cairo_context.new_path()
+
+    def _draw_layout(self, context, x, y, width, height, underline_drawer):
+        line_height = 0
+        alignment = self.layout.get_alignment()
+        for i in xrange(self.layout.get_line_count()):
+            line = self.layout.get_line_readonly(i)
+            extents = line.get_pixel_extents()[1]
+            next_line_height = line_height + extents[3]
+            if next_line_height > height:
+                break
+            if alignment == pango.ALIGN_CENTER:
+                line_x = max(x, x + (width - extents[2]) / 2.0)
+            elif alignment == pango.ALIGN_RIGHT:
+                line_x = max(x, x + width - extents[2])
+            else:
+                line_x = x
+            baseline = y + line_height + pango.ASCENT(extents)
+            context.move_to(line_x, baseline)
+            context.context.show_layout_line(line)
+            underline_drawer.draw(context, line_x, baseline, line)
+            line_height = next_line_height
+
+class UnderlineDrawer(object):
+    """Class to draw our own underlines because cairo's don't look
+    that great at small fonts.  We make sure that the underline is
+    always drawn at a pixel boundary and that there always is space
+    between the text and the baseline.
+
+    This class makes a couple assumptions that might not be that
+    great.  It assumes that the correct underline size is 1 pixel and
+    that the text color doesn't change in the middle of an underline.
+    """
+    def __init__(self, underlines):
+        self.underline_iter = iter(underlines)
+        self.finished = False
+        self.next_underline()
+
+    def next_underline(self):
+        try:
+            self.startpos, self.endpos = self.underline_iter.next()
+        except StopIteration:
+            self.finished = True
+        else:
+            # endpos is the char to stop underlining at
+            self.endpos -= 1
+
+    def draw(self, context, x, baseline, line):
+        baseline = round(baseline) + 0.5
+        context.set_line_width(1)
+        while not self.finished and line.start_index <= self.startpos:
+            startpos = max(line.start_index, self.startpos)
+            endpos = min(self.endpos, line.start_index + line.length)
+            x1 = x + pango.PIXELS(line.index_to_x(startpos, 0))
+            x2 = x + pango.PIXELS(line.index_to_x(endpos, 1))
+            context.move_to(x1, baseline + 1)
+            context.line_to(x2, baseline + 1)
+            context.stroke()
+            if endpos < self.endpos:
+                break
+            else:
+                self.next_underline()
+
+class NativeButton(object):
+    ICON_PAD = 4
+
+    def __init__(self, text, context, font, pressed, style, widget):
+        self.layout = pango.Layout(context)
+        self.font = font
+        self.pressed = pressed
+        self.layout.set_font_description(font.description.copy())
+        self.layout.set_text(text)
+        self.pad_x = style.xthickness + 11
+        self.pad_y = style.ythickness + 1
+        self.style = style
+        self.widget = widget
+        # The above code assumes an "inner-border" style property of
+        # 1. PyGTK doesn't seem to support Border objects very well,
+        # so can't get it from the widget style.
+        self.min_width = 0
+        self.icon = None
+
+    def set_min_width(self, width):
+        self.min_width = width
+
+    def set_icon(self, icon):
+        self.icon = icon
+
+    def get_size(self):
+        width, height = self.layout.get_pixel_size()
+        if self.icon:
+            width += self.icon.width + self.ICON_PAD
+            height = max(height, self.icon.height)
+        width += self.pad_x * 2
+        height += self.pad_y * 2
+        return max(self.min_width, width), height
+
+    def draw(self, context, x, y, width, height):
+        text_width, text_height = self.layout.get_pixel_size()
+        if self.icon:
+            inner_width = text_width + self.icon.width + self.ICON_PAD
+            # calculate the icon position x and y are still in cairo
+            # coordinates
+            icon_x = x + (width - inner_width) / 2.0
+            icon_y = y + (height - self.icon.height) / 2.0
+            text_x = icon_x + self.icon.width + self.ICON_PAD
+        else:
+            text_x = x + (width - text_width) / 2.0
+        text_y = y + (height - text_height) / 2.0
+
+        x, y = context.context.user_to_device(x, y)
+        text_x, text_y = context.context.user_to_device(text_x, text_y)
+        # Hmm, maybe we should somehow support floating point numbers
+        # here, but I don't know how to.
+        x, y, width, height = (int(f) for f in (x, y, width, height))
+        context.context.get_target().flush()
+        self.draw_box(context.window, x, y, width, height)
+        self.draw_text(context.window, text_x, text_y)
+        if self.icon:
+            self.icon.draw(context, icon_x, icon_y, self.icon.width,
+                    self.icon.height)
+
+    def draw_box(self, window, x, y, width, height):
+        if self.pressed:
+            shadow = gtk.SHADOW_IN
+            state = gtk.STATE_ACTIVE
+        else:
+            shadow = gtk.SHADOW_OUT
+            state = gtk.STATE_NORMAL
+        if 'QtCurveStyle' in str(self.style):
+            # This is a horrible hack for the libqtcurve library.  See
+            # http://bugzilla.pculture.org/show_bug.cgi?id=10380 for
+            # details
+            widget = window.get_user_data()
+        else:
+            widget = self.widget
+
+        self.style.paint_box(window, state, shadow, None, widget, "button",
+                int(x), int(y), int(width), int(height))
+
+    def draw_text(self, window, x, y):
+        if self.pressed:
+            state = gtk.STATE_ACTIVE
+        else:
+            state = gtk.STATE_NORMAL
+        self.style.paint_layout(window, state, True, None, None, None,
+                int(x), int(y), self.layout)
+
+class StyledButton(object):
+    PAD_HORIZONTAL = 4
+    PAD_VERTICAL = 3
+    TOP_COLOR = (1, 1, 1)
+    BOTTOM_COLOR = (0.86, 0.86, 0.86)
+    LINE_COLOR_TOP = (0.71, 0.71, 0.71)
+    LINE_COLOR_BOTTOM = (0.45, 0.45, 0.45)
+    TEXT_COLOR = (0.184, 0.184, 0.184)
+    DISABLED_COLOR = (0.86, 0.86, 0.86)
+    DISABLED_TEXT_COLOR = (0.5, 0.5, 0.5)
+    ICON_PAD = 8
+
+    def __init__(self, text, context, font, pressed, disabled=False):
+        self.layout = pango.Layout(context)
+        self.font = font
+        self.layout.set_font_description(font.description.copy())
+        self.layout.set_text(text)
+        self.min_width = 0
+        self.pressed = pressed
+        self.disabled = disabled
+        self.icon = None
+
+    def set_icon(self, icon):
+        self.icon = icon
+
+    def set_min_width(self, width):
+        self.min_width = width
+
+    def get_size(self):
+        width, height = self.layout.get_pixel_size()
+        if self.icon:
+            width += self.icon.width + self.ICON_PAD
+            height = max(height, self.icon.height)
+        height += self.PAD_VERTICAL * 2
+        if height % 2 == 1:
+            # make height even so that the radius of our circle is
+            # whole
+            height += 1
+        width += self.PAD_HORIZONTAL * 2 + height
+        return max(self.min_width, width), height
+
+    def draw_path(self, context, x, y, width, height, radius):
+        inner_width = width - radius * 2
+        context.move_to(x + radius, y)
+        context.rel_line_to(inner_width, 0)
+        context.arc(x + width - radius, y+radius, radius, -math.pi/2,
+                    math.pi/2)
+        context.rel_line_to(-inner_width, 0)
+        context.arc(x + radius, y+radius, radius, math.pi/2, -math.pi/2)
+
+    def draw_button(self, context, x, y, width, height, radius):
+        context.context.save()
+        self.draw_path(context, x, y, width, height, radius)
+        if self.disabled:
+            end_color = self.DISABLED_COLOR
+            start_color = self.DISABLED_COLOR
+        elif self.pressed:
+            end_color = self.TOP_COLOR
+            start_color = self.BOTTOM_COLOR
+        else:
+            context.set_line_width(1)
+            start_color = self.TOP_COLOR
+            end_color = self.BOTTOM_COLOR
+        gradient = cairo.LinearGradient(x, y, x, y + height)
+        gradient.add_color_stop_rgb(0, *start_color)
+        gradient.add_color_stop_rgb(1, *end_color)
+        context.context.set_source(gradient)
+        context.fill()
+        context.set_line_width(1)
+        self.draw_path(context, x+0.5, y+0.5, width, height, radius)
+        gradient = cairo.LinearGradient(x, y, x, y + height)
+        gradient.add_color_stop_rgb(0, *self.LINE_COLOR_TOP)
+        gradient.add_color_stop_rgb(1, *self.LINE_COLOR_BOTTOM)
+        context.context.set_source(gradient)
+        context.stroke()
+        context.context.restore()
+
+    def draw(self, context, x, y, width, height):
+        radius = height / 2
+        self.draw_button(context, x, y, width, height, radius)
+
+        text_width, text_height = self.layout.get_pixel_size()
+        # draw the text in the center of the button
+        text_x = x + (width - text_width) / 2
+        text_y = y + (height - text_height) / 2
+        if self.icon:
+            icon_x = text_x - (self.icon.width + self.ICON_PAD) / 2
+            text_x += (self.icon.width + self.ICON_PAD) / 2
+            icon_y = y + (height - self.icon.height) / 2
+            self.icon.draw(context, icon_x, icon_y, self.icon.width,
+                    self.icon.height)
+        self.draw_text(context, text_x, text_y, width, height, radius)
+
+    def draw_text(self, context, x, y, width, height, radius):
+        if self.disabled:
+            context.set_color(self.DISABLED_TEXT_COLOR)
+        else:
+            context.set_color(self.TEXT_COLOR)
+        context.move_to(x, y)
+        context.context.show_layout(self.layout)
diff --git a/lvc/widgets/gtk/simple.py b/lvc/widgets/gtk/simple.py
new file mode 100644
index 0000000..102fcd4
--- /dev/null
+++ b/lvc/widgets/gtk/simple.py
@@ -0,0 +1,313 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""simple.py -- Collection of simple widgets."""
+
+import gtk
+import gobject
+import pango
+
+from lvc.widgets import widgetconst
+from .base import Widget, Bin
+
+class Image(object):
+    def __init__(self, path):
+        try:
+            self._set_pixbuf(gtk.gdk.pixbuf_new_from_file(path))
+        except gobject.GError, ge:
+            raise ValueError("%s" % ge)
+        self.width = self.pixbuf.get_width()
+        self.height = self.pixbuf.get_height()
+
+    def _set_pixbuf(self, pixbuf):
+        self.pixbuf = pixbuf
+        self.width = self.pixbuf.get_width()
+        self.height = self.pixbuf.get_height()
+
+    def resize(self, width, height):
+        width = int(round(width))
+        height = int(round(height))
+        resized_pixbuf = self.pixbuf.scale_simple(width, height,
+                gtk.gdk.INTERP_BILINEAR)
+        return TransformedImage(resized_pixbuf)
+
+    def resize_for_space(self, width, height):
+        """Returns an image scaled to fit into the specified space at the
+        correct height/width ratio.
+        """
+        ratio = min(1.0 * width / self.width, 1.0 * height / self.height)
+        return self.resize(ratio * self.width, ratio * self.height)
+
+    def crop_and_scale(self, src_x, src_y, src_width, src_height, dest_width,
+            dest_height):
+        """Crop an image then scale it.
+
+        The image will be cropped to the rectangle (src_x, src_y, src_width,
+        src_height), that rectangle will be scaled to a new Image with tisez
+        (dest_width, dest_height)
+        """
+        dest = gtk.gdk.Pixbuf(self.pixbuf.get_colorspace(),
+                self.pixbuf.get_has_alpha(),
+                self.pixbuf.get_bits_per_sample(), dest_width, dest_height)
+
+        scale_x = dest_width / float(src_width)
+        scale_y = dest_height / float(src_height)
+
+        self.pixbuf.scale(dest, 0, 0, dest_width, dest_height,
+                -src_x * scale_x, -src_y * scale_y, scale_x, scale_y,
+                gtk.gdk.INTERP_BILINEAR)
+        return TransformedImage(dest)
+
+class TransformedImage(Image):
+    def __init__(self, pixbuf):
+        # XXX intentionally not calling direct super's __init__; we should do
+        # this differently
+        self._set_pixbuf(pixbuf)
+
+class ImageDisplay(Widget):
+    def __init__(self, image=None):
+        Widget.__init__(self)
+        self.set_widget(gtk.Image())
+        self.set_image(image)
+
+    def set_image(self, image):
+        self.image = image
+        if image is not None:
+            self._widget.set_from_pixbuf(image.pixbuf)
+        else:
+            self._widget.clear()
+
+class AnimatedImageDisplay(Widget):
+    def __init__(self, path):
+        Widget.__init__(self)
+        self.set_widget(gtk.Image())
+        self._animation = gtk.gdk.PixbufAnimation(path)
+        # Set to animate before we are shown and stop animating after
+        # we disappear.
+        self._widget.connect('map', lambda w: self._set_animate(True))
+        self._widget.connect('unmap-event',
+                             lambda w, a: self._set_animate(False))
+
+    def _set_animate(self, enabled):
+        if enabled:
+            self._widget.set_from_animation(self._animation)
+        else:
+            self._widget.clear()
+
+class Label(Widget):
+    """Widget that displays simple text."""
+    def __init__(self, text="", color=None):
+        Widget.__init__(self)
+        self.set_widget(gtk.Label())
+        if text:
+            self.set_text(text)
+        self.attr_list = pango.AttrList()
+        self.font_description = self._widget.style.font_desc.copy()
+        self.scale_factor = 1.0
+        if color is not None:
+            self.set_color(color)
+        self.wrapped_widget_connect('style-set', self.on_style_set)
+
+    def set_bold(self, bold):
+        if bold:
+            weight = pango.WEIGHT_BOLD
+        else:
+            weight = pango.WEIGHT_NORMAL
+        self.font_description.set_weight(weight)
+        self.set_attr(pango.AttrFontDesc(self.font_description))
+
+    def set_size(self, size):
+        if size == widgetconst.SIZE_NORMAL:
+            self.scale_factor = 1
+        elif size == widgetconst.SIZE_SMALL:
+            self.scale_factor = 0.75
+        else:
+            self.scale_factor = size
+        baseline = self._widget.style.font_desc.get_size()
+        self.font_description.set_size(int(baseline * self.scale_factor))
+        self.set_attr(pango.AttrFontDesc(self.font_description))
+
+    def get_preferred_width(self):
+        return self._widget.size_request()[0]
+
+    def on_style_set(self, widget, old_style):
+        self.set_size(self.scale_factor)
+
+    def set_wrap(self, wrap):
+        self._widget.set_line_wrap(wrap)
+
+    def set_alignment(self, alignment):
+        # default to left.
+        gtkalignment = gtk.JUSTIFY_LEFT
+        if alignment == widgetconst.TEXT_JUSTIFY_LEFT:
+            gtkalignment = gtk.JUSTIFY_LEFT
+        elif alignment == widgetconst.TEXT_JUSTIFY_RIGHT:
+            gtkalignment = gtk.JUSTIFY_RIGHT
+        elif alignment == widgetconst.TEXT_JUSTIFY_CENTER:
+            gtkalignment = gtk.JUSTIFY_CENTER
+        self._widget.set_justify(gtkalignment)
+
+    def get_alignment(self):
+        return self._widget.get_justify()
+
+    def get_width(self):
+        return self._widget.get_layout().get_pixel_size()[0]
+
+    def set_text(self, text):
+        self._widget.set_text(text)
+
+    def get_text(self):
+        return self._widget.get_text().decode('utf-8')
+
+    def set_selectable(self, val):
+        self._widget.set_selectable(val)
+
+    def set_attr(self, attr):
+        attr.end_index = 65535
+        self.attr_list.change(attr)
+        self._widget.set_attributes(self.attr_list)
+
+    def set_color(self, color):
+        color_as_int = (int(65535 * c) for c in color)
+        self.set_attr(pango.AttrForeground(*color_as_int))
+
+    def baseline(self):
+        pango_context = self._widget.get_pango_context()
+        metrics = pango_context.get_metrics(self.font_description)
+        return pango.PIXELS(metrics.get_descent())
+
+    def hide(self):
+        self._widget.hide()
+
+    def show(self):
+        self._widget.show()
+
+class Scroller(Bin):
+    def __init__(self, horizontal, vertical):
+        Bin.__init__(self)
+        self.set_widget(gtk.ScrolledWindow())
+        if horizontal:
+            h_policy = gtk.POLICY_AUTOMATIC
+        else:
+            h_policy = gtk.POLICY_NEVER
+        if vertical:
+            v_policy = gtk.POLICY_AUTOMATIC
+        else:
+            v_policy = gtk.POLICY_NEVER
+        self._widget.set_policy(h_policy, v_policy)
+
+    def set_has_borders(self, has_border):
+        pass
+
+    def set_background_color(self, color):
+        pass
+
+    def add_child_to_widget(self):
+        if (isinstance(self.child._widget, gtk.TreeView) or
+                isinstance(self.child._widget, gtk.TextView)):
+            # child has native scroller
+            self._widget.add(self.child._widget)
+        else:
+            self._widget.add_with_viewport(self.child._widget)
+            self._widget.get_child().set_shadow_type(gtk.SHADOW_NONE)
+        if isinstance(self.child._widget, gtk.TextView):
+            self._widget.set_shadow_type(gtk.SHADOW_IN)
+        else:
+            self._widget.set_shadow_type(gtk.SHADOW_NONE)
+
+    def prepare_for_dark_content(self):
+        # this is just a hack for cocoa
+        pass
+
+
+class SolidBackground(Bin):
+    def __init__(self, color=None):
+        Bin.__init__(self)
+        self.set_widget(gtk.EventBox())
+        if color is not None:
+            self.set_background_color(color)
+
+    def set_background_color(self, color):
+        self.modify_style('base', gtk.STATE_NORMAL, self.make_color(color))
+        self.modify_style('bg', gtk.STATE_NORMAL, self.make_color(color))
+
+class Expander(Bin):
+    def __init__(self, child=None):
+        Bin.__init__(self)
+        self.set_widget(gtk.Expander())
+        if child is not None:
+            self.add(child)
+        self.label = None
+        # This is a complete hack.  GTK expanders have a transparent
+        # background most of the time, except when they are prelighted.  So we
+        # just set the background to white there because that's what should
+        # happen in the item list.
+        self.modify_style('bg', gtk.STATE_PRELIGHT,
+                gtk.gdk.color_parse('white'))
+
+    def set_spacing(self, spacing):
+        self._widget.set_spacing(spacing)
+
+    def set_label(self, widget):
+        self.label = widget
+        self._widget.set_label_widget(widget._widget)
+        widget._widget.show()
+
+    def set_expanded(self, expanded):
+        self._widget.set_expanded(expanded)
+
+class ProgressBar(Widget):
+    def __init__(self):
+        Widget.__init__(self)
+        self.set_widget(gtk.ProgressBar())
+        self._timer = None
+
+    def set_progress(self, fraction):
+        self._widget.set_fraction(fraction)
+
+    def start_pulsing(self):
+        if self._timer is None:
+            self._timer = gobject.timeout_add(100, self._do_pulse)
+
+    def stop_pulsing(self):
+        if self._timer:
+            gobject.source_remove(self._timer)
+            self._timer = None
+
+    def _do_pulse(self):
+        self._widget.pulse()
+        return True
+
+class HLine(Widget):
+    """A horizontal separator. Not to be confused with HSeparator, which is is
+    a DrawingArea, not a Widget.
+    """
+    def __init__(self):
+        Widget.__init__(self)
+        self.set_widget(gtk.HSeparator())
diff --git a/lvc/widgets/gtk/tableview.py b/lvc/widgets/gtk/tableview.py
new file mode 100644
index 0000000..df66990
--- /dev/null
+++ b/lvc/widgets/gtk/tableview.py
@@ -0,0 +1,1557 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""tableview.py -- Wrapper for the GTKTreeView widget.  It's used for the tab
+list and the item list (AKA almost all of the miro).
+"""
+
+import logging
+
+import itertools
+import gobject
+import gtk
+from collections import namedtuple
+
+# These are probably wrong, and are placeholders for now, until custom headers
+# are also implemented for GTK.
+CUSTOM_HEADER_HEIGHT = 25
+HEADER_HEIGHT = 25
+
+from lvc import signals
+from lvc.errors import (WidgetActionError, WidgetDomainError,
+                                WidgetRangeError, WidgetNotReadyError)
+from lvc.widgets.tableselection import SelectionOwnerMixin
+from lvc.widgets.tablescroll import ScrollbarOwnerMixin
+import drawing
+import wrappermap
+from .base import Widget
+from .simple import Image
+from .layoutmanager import LayoutManager
+from .weakconnect import weak_connect
+from .tableviewcells import GTKCustomCellRenderer
+
+
+PathInfo = namedtuple('PathInfo', 'path column x y')
+Rect = namedtuple('Rect', 'x y width height')
+_album_view_gtkrc_installed = False
+
+def _install_album_view_gtkrc():
+    """Hack for styling GTKTreeView for the album view widget.
+
+    We do a couple things:
+      - Remove the focus ring
+      - Remove any separator space.
+
+    We do this so that we don't draw a box through the album view column for
+    selected rows.
+    """
+    global _album_view_gtkrc_installed
+    if _album_view_gtkrc_installed:
+        return
+    rc_string = ('style "album-view-style"\n'
+                 '{ \n'
+                 '  GtkTreeView::vertical-separator = 0\n'
+                 '  GtkTreeView::horizontal-separator = 0\n'
+                 '  GtkWidget::focus-line-width = 0 \n'
+                 '}\n'
+                 'widget "*.miro-album-view" style "album-view-style"\n')
+    gtk.rc_parse_string(rc_string)
+    _album_view_gtkrc_installed = True
+
+def rect_contains_point(rect, x, y):
+    return ((rect.x <= x < rect.x + rect.width) and
+            (rect.y <= y < rect.y + rect.height))
+
+class TreeViewScrolling(object):
+    def __init__(self):
+        self.scrollbars = []
+        self.scroll_positions = None, None
+        self.restoring_scroll = None
+        self.connect('parent-set', self.on_parent_set)
+        self.scroller = None
+        # hack necessary because of our weird widget hierarchy (GTK doesn't deal
+        # well with the Scroller's widget not being the direct parent of the
+        # TableView's widget.)
+        self._coords_working = False
+
+    def scroll_range_changed(self):
+        """Faux-signal; this should all be integrated into
+        GTKScrollbarOwnerMixin, making this unnecessary.
+        """
+
+    @property
+    def manually_scrolled(self):
+        """Return whether the view has been scrolled explicitly by the user
+        since the last time it was set automatically.
+        """
+        auto_pos = self.scroll_positions[1]
+        if auto_pos is None:
+            # if we don't have any position yet, user can't have manually
+            # scrolled
+            return False
+        real_pos = self.scrollbars[1].get_value()
+        return abs(auto_pos - real_pos) > 5 # allowing some fuzziness
+
+    @property
+    def position_set(self):
+        """Return whether the scroll position has been set in any way."""
+        return any(x is not None for x in self.scroll_positions)
+
+    def on_parent_set(self, widget, old_parent):
+        """We have parent window now; we need to control its scrollbars."""
+        self.set_scroller(widget.get_parent())
+
+    def set_scroller(self, window):
+        """Take control of the scrollbars of window."""
+        if not isinstance(window, gtk.ScrolledWindow):
+            return
+        self.scroller = window
+        scrollbars = tuple(bar.get_adjustment()
+            for bar in (window.get_hscrollbar(), window.get_vscrollbar()))
+        self.scrollbars = scrollbars
+        for i, bar in enumerate(scrollbars):
+            weak_connect(bar, 'changed', self.on_scroll_range_changed, i)
+        if self.restoring_scroll:
+            self.set_scroll_position(self.restoring_scroll)
+
+    def on_scroll_range_changed(self, adjustment, bar):
+        """The scrollbar might have a range now. Set its initial position if
+        we haven't already.
+        """
+        self._coords_working = True
+        if self.restoring_scroll:
+            self.set_scroll_position(self.restoring_scroll)
+        # our wrapper handles the same thing for iters
+        self.scroll_range_changed()
+
+    def set_scroll_position(self, scroll_position):
+        """Restore the scrollbars to a remembered state."""
+        try:
+            self.scroll_positions = tuple(self._clip_pos(adj, x)
+                    for adj, x in zip(self.scrollbars, scroll_position))
+        except WidgetActionError, error:
+            logging.debug("can't scroll yet: %s", error.reason)
+            # try again later
+            self.restoring_scroll = scroll_position
+        else:
+            for adj, pos in zip(self.scrollbars, self.scroll_positions):
+                adj.set_value(pos)
+            self.restoring_scroll = None
+
+    def _clip_pos(self, adj, pos):
+        lower = adj.get_lower()
+        upper = adj.get_upper() - adj.get_page_size()
+        # currently, StandardView gets an upper of 2.0 when it's not ready
+        # FIXME: don't count on that
+        if pos > upper and upper < 5:
+            raise WidgetRangeError("scrollable area", pos, lower, upper)
+        return min(max(pos, lower), upper)
+
+    def get_path_rect(self, path):
+        """Return the Rect for the given item, in tree coords."""
+        if not self._coords_working:
+            # part of solution to #17405; widget_to_tree_coords tends to return
+            # y=8 before the first scroll-range-changed signal. ugh.
+            raise WidgetNotReadyError('_coords_working')
+        rect = self.get_background_area(path, self.get_columns()[0])
+        x, y = self.widget_to_tree_coords(rect.x, rect.y)
+        return Rect(x, y, rect.width, rect.height)
+
+    @property
+    def _scrollbars(self):
+        if not self.scrollbars:
+            raise WidgetNotReadyError
+        return self.scrollbars
+
+    def scroll_ancestor(self, newly_selected, down):
+        # Try to figure out what just became selected.  If multiple things
+        # somehow became selected, select the outermost one
+        if len(newly_selected) == 0:
+            raise WidgetActionError("need at an item to scroll to")
+        if down:
+            path_to_show = max(newly_selected)
+        else:
+            path_to_show = min(newly_selected)
+
+        if not self.scrollbars:
+            return
+        vadjustment = self.scrollbars[1]
+
+        rect = self.get_background_area(path_to_show, self.get_columns()[0])
+        _, top = self.translate_coordinates(self.scroller, 0, rect.y)
+        top += vadjustment.value
+        bottom = top + rect.height
+        if down:
+            if bottom > vadjustment.value + vadjustment.page_size:
+                bottom_value = min(bottom, vadjustment.upper)
+                vadjustment.set_value(bottom_value - vadjustment.page_size)
+        else:
+            if top < vadjustment.value:
+                vadjustment.set_value(max(vadjustment.lower, top))
+
+class MiroTreeView(gtk.TreeView, TreeViewScrolling):
+    """Extends the GTK TreeView widget to help implement TableView
+    https://develop.participatoryculture.org/index.php/WidgetAPITableView"""
+    # Add a tiny bit of padding so that the user can drag feeds below
+    # the table, i.e. to the bottom row, as a top-level
+    PAD_BOTTOM = 3
+    def __init__(self):
+        gtk.TreeView.__init__(self)
+        TreeViewScrolling.__init__(self)
+        self.height_without_pad_bottom = -1
+        self.set_enable_search(False)
+        self.horizontal_separator = self.style_get_property("horizontal-separator")
+        self.expander_size = self.style_get_property("expander-size")
+        self.group_lines_enabled = False
+        self.group_line_color = (0, 0, 0)
+        self.group_line_width = 1
+
+    def do_size_request(self, req):
+        gtk.TreeView.do_size_request(self, req)
+        self.height_without_pad_bottom = req.height
+        req.height += self.PAD_BOTTOM
+
+    def do_move_cursor(self, step, count):
+        if step == gtk.MOVEMENT_VISUAL_POSITIONS:
+            # GTK is asking us to move left/right.  Since our TableViews don't
+            # support this, return False to let the key press propagate.  See
+            # #15646 for more info.
+            return False
+        if isinstance(self.get_parent(), gtk.ScrolledWindow):
+            # If our parent is a ScrolledWindow, let GTK take care of this
+            handled = gtk.TreeView.do_move_cursor(self, step, count)
+            return handled
+        else:
+            # Otherwise, we have to search up the widget tree for a
+            # ScrolledWindow to take care of it
+            selection = self.get_selection()
+            model, start_selection = selection.get_selected_rows()
+            gtk.TreeView.do_move_cursor(self, step, count)
+
+            model, end_selection = selection.get_selected_rows()
+            newly_selected = set(end_selection) - set(start_selection)
+            down = (count > 0)
+
+            try:
+                self.scroll_ancestor(newly_selected, down)
+            except WidgetActionError:
+                # not possible
+                return False
+            return True
+
+    def get_position_info(self, x, y):
+        """Wrapper for get_path_at_pos that converts the path_info to a named
+        tuple and handles rounding the coordinates.
+        """
+        path_info = self.get_path_at_pos(int(round(x)), int(round(y)))
+        if path_info:
+            return PathInfo(*path_info)
+
+gobject.type_register(MiroTreeView)
+
+class HotspotTracker(object):
+    """Handles tracking hotspots.
+    https://develop.participatoryculture.org/index.php/WidgetAPITableView"""
+
+    def __init__(self, treeview, event):
+        self.treeview = treeview
+        self.treeview_wrapper = wrappermap.wrapper(treeview)
+        self.hit = False
+        self.button = event.button
+        path_info = treeview.get_position_info(event.x, event.y)
+        if path_info is None:
+            return
+        self.path, self.column, background_x, background_y = path_info
+        # We always pack 1 renderer for each column
+        gtk_renderer = self.column.get_cell_renderers()[0]
+        if not isinstance(gtk_renderer, GTKCustomCellRenderer):
+            return
+        self.renderer = wrappermap.wrapper(gtk_renderer)
+        self.attr_map = self.treeview_wrapper.attr_map_for_column[self.column]
+        if not rect_contains_point(self.calc_cell_area(), event.x, event.y):
+            # Mouse is in the padding around the actual cell area
+            return
+        self.update_position(event)
+        self.iter = treeview.get_model().get_iter(self.path)
+        self.name = self.calc_hotspot()
+        if self.name is not None:
+            self.hit = True
+
+    def is_for_context_menu(self):
+        return self.name == "#show-context-menu"
+
+    def calc_cell_area(self):
+        cell_area = self.treeview.get_cell_area(self.path, self.column)
+        xpad = self.renderer._renderer.props.xpad
+        ypad = self.renderer._renderer.props.ypad
+        cell_area.x += xpad
+        cell_area.y += ypad
+        cell_area.width -= xpad * 2
+        cell_area.height -= ypad * 2
+        return cell_area
+
+    def update_position(self, event):
+        self.x, self.y = int(event.x), int(event.y)
+
+    def calc_cell_state(self):
+        if self.treeview.get_selection().path_is_selected(self.path):
+            if self.treeview.flags() & gtk.HAS_FOCUS:
+                return gtk.STATE_SELECTED
+            else:
+                return gtk.STATE_ACTIVE
+        else:
+            return gtk.STATE_NORMAL
+
+    def calc_hotspot(self):
+        cell_area = self.calc_cell_area()
+        if rect_contains_point(cell_area, self.x, self.y):
+            model = self.treeview.get_model()
+            self.renderer.cell_data_func(self.column, self.renderer._renderer,
+                    model, self.iter, self.attr_map)
+            style = drawing.DrawingStyle(self.treeview_wrapper,
+                use_base_color=True, state=self.calc_cell_state())
+            x = self.x - cell_area.x
+            y = self.y - cell_area.y
+            return self.renderer.hotspot_test(style,
+                    self.treeview_wrapper.layout_manager,
+                    x, y, cell_area.width, cell_area.height)
+        else:
+            return None
+
+    def update_hit(self):
+        if self.is_for_context_menu():
+            return # we always keep hit = True for this one
+        old_hit = self.hit
+        self.hit = (self.calc_hotspot() == self.name)
+        if self.hit != old_hit:
+            self.redraw_cell()
+
+    def redraw_cell(self):
+        # Check that the treeview is still around.  We might have switched
+        # views in response to a hotspot being clicked.
+        if self.treeview.flags() & gtk.REALIZED:
+            cell_area = self.treeview.get_cell_area(self.path, self.column)
+            x, y = self.treeview.tree_to_widget_coords(cell_area.x,
+                                                       cell_area.y)
+            self.treeview.queue_draw_area(x, y,
+                    cell_area.width, cell_area.height)
+
+class TableColumn(signals.SignalEmitter):
+    """A single column of a TableView.
+
+    Signals:
+
+        clicked (table_column) -- The header for this column was clicked.
+    """
+    # GTK hard-codes 4px of padding for each column
+    FIXED_PADDING = 4
+    def __init__(self, title, renderer, header=None, **attrs):
+        # header widget not used yet in GTK (#15800)
+        signals.SignalEmitter.__init__(self)
+        self.create_signal('clicked')
+        self._column = gtk.TreeViewColumn(title, renderer._renderer)
+        self._column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
+        self._column.set_clickable(True)
+        self.attrs = attrs
+        renderer.setup_attributes(self._column, attrs)
+        self.renderer = renderer
+        weak_connect(self._column, 'clicked', self._header_clicked)
+        self.do_horizontal_padding = True
+
+    def set_right_aligned(self, right_aligned):
+        """Horizontal alignment of the header label."""
+        if right_aligned:
+            self._column.set_alignment(1.0)
+        else:
+            self._column.set_alignment(0.0)
+
+    def set_min_width(self, width):
+        self._column.props.min_width = width + TableColumn.FIXED_PADDING
+
+    def set_max_width(self, width):
+        self._column.props.max_width = width
+
+    def set_width(self, width):
+        self._column.set_fixed_width(width + TableColumn.FIXED_PADDING)
+
+    def get_width(self):
+        return self._column.get_width()
+
+    def _header_clicked(self, tablecolumn):
+        self.emit('clicked')
+
+    def set_resizable(self, resizable):
+        """Set if the user can resize the column."""
+        self._column.set_resizable(resizable)
+
+    def set_do_horizontal_padding(self, horizontal_padding):
+        self.do_horizontal_padding = False
+
+    def set_sort_indicator_visible(self, visible):
+        """Show/Hide the sort indicator for this column."""
+        self._column.set_sort_indicator(visible)
+
+    def get_sort_indicator_visible(self):
+        return self._column.get_sort_indicator()
+
+    def set_sort_order(self, ascending):
+        """Display a sort indicator on the column header.  Ascending can be
+        either True or False which affects the direction of the indicator.
+        """
+        if ascending:
+            self._column.set_sort_order(gtk.SORT_ASCENDING)
+        else:
+            self._column.set_sort_order(gtk.SORT_DESCENDING)
+
+    def get_sort_order_ascending(self):
+        """Returns if the sort indicator is displaying that the sort is
+        ascending.
+        """
+        return self._column.get_sort_order() == gtk.SORT_ASCENDING
+
+class GTKSelectionOwnerMixin(SelectionOwnerMixin):
+    """GTK-specific methods for selection management.
+
+    This subclass should not define any behavior. Methods that cannot be
+    completed in this widget state should raise WidgetActionError.
+    """
+    def __init__(self):
+        SelectionOwnerMixin.__init__(self)
+        self.selection = self._widget.get_selection()
+        weak_connect(self.selection, 'changed', self.on_selection_changed)
+
+    def _set_allow_multiple_select(self, allow):
+        if allow:
+            mode = gtk.SELECTION_MULTIPLE
+        else:
+            mode = gtk.SELECTION_SINGLE
+        self.selection.set_mode(mode)
+
+    def _get_allow_multiple_select(self):
+        return self.selection.get_mode() == gtk.SELECTION_MULTIPLE
+
+    def _get_selected_iters(self):
+        iters = []
+        def collect(treemodel, path, iter_):
+            iters.append(iter_)
+        self.selection.selected_foreach(collect)
+        return iters
+
+    def _get_selected_iter(self):
+        model, iter_ = self.selection.get_selected()
+        return iter_
+
+    @property
+    def num_rows_selected(self):
+        return self.selection.count_selected_rows()
+
+    def _is_selected(self, iter_):
+        return self.selection.iter_is_selected(iter_)
+
+    def _select(self, iter_):
+        self.selection.select_iter(iter_)
+
+    def _unselect(self, iter_):
+        self.selection.unselect_iter(iter_)
+
+    def _unselect_all(self):
+        self.selection.unselect_all()
+
+    def _iter_to_string(self, iter_):
+        return self._model.get_string_from_iter(iter_)
+
+    def _iter_from_string(self, string):
+        try:
+            return self._model.get_iter_from_string(string)
+        except ValueError:
+            raise WidgetDomainError(
+                  "model iters", string, "%s other iters" % len(self.model))
+
+    def select_path(self, path):
+        self.selection.select_path(path)
+
+    def _validate_iter(self, iter_):
+        if self.get_path(iter_) is None:
+            raise WidgetDomainError(
+                  "model iters", iter_, "%s other iters" % len(self.model))
+        real_model = self._widget.get_model()
+        if not real_model:
+            raise WidgetActionError("no model")
+        elif real_model != self._model:
+            raise WidgetActionError("wrong model?")
+
+    def get_cursor(self):
+        """Return the path of the 'focused' item."""
+        path, column = self._widget.get_cursor()
+        return path
+
+    def set_cursor(self, path):
+        """Set the path of the 'focused' item."""
+        if path is None:
+            # XXX: is there a way to clear the cursor?
+            return
+        path_as_string = ':'.join(str(component) for component in path)
+        with self.preserving_selection(): # set_cursor() messes up the selection
+            self._widget.set_cursor(path_as_string)
+
+class DNDHandlerMixin(object):
+    """TableView row DnD.
+
+    Depends on arbitrary TableView methods; otherwise self-contained except:
+        on_button_press: may call start_drag
+        on_button_release: may unset drag_button_down
+        on_motion_notify: may call potential_drag_motion
+    """
+    def __init__(self):
+        self.drag_button_down = False
+        self.drag_data = {}
+        self.drag_source = self.drag_dest = None
+        self.drag_start_x, self.drag_start_y = None, None
+        self.wrapped_widget_connect('drag-data-get', self.on_drag_data_get)
+        self.wrapped_widget_connect('drag-end', self.on_drag_end)
+        self.wrapped_widget_connect('drag-motion', self.on_drag_motion)
+        self.wrapped_widget_connect('drag-leave', self.on_drag_leave)
+        self.wrapped_widget_connect('drag-drop', self.on_drag_drop)
+        self.wrapped_widget_connect('drag-data-received',
+                self.on_drag_data_received)
+        self.wrapped_widget_connect('unrealize', self.on_drag_unrealize)
+
+    def set_drag_source(self, drag_source):
+        self.drag_source = drag_source
+        # XXX: the following note no longer seems accurate:
+        # No need to call enable_model_drag_source() here, we handle it
+        # ourselves in on_motion_notify()
+
+    def set_drag_dest(self, drag_dest):
+        """Set the drop handler."""
+        self.drag_dest = drag_dest
+        if drag_dest is not None:
+            targets = self._gtk_target_list(drag_dest.allowed_types())
+            self._widget.enable_model_drag_dest(targets,
+                    drag_dest.allowed_actions())
+            self._widget.drag_dest_set(0, targets,
+                    drag_dest.allowed_actions())
+        else:
+            self._widget.unset_rows_drag_dest()
+            self._widget.drag_dest_unset()
+
+    def start_drag(self, treeview, event, path_info):
+        """Check whether the event is a drag event; return whether handled
+        here.
+        """
+        if event.state & (gtk.gdk.CONTROL_MASK | gtk.gdk.SHIFT_MASK):
+            return False
+        model, row_paths = treeview.get_selection().get_selected_rows()
+
+        if path_info.path not in row_paths:
+            # something outside the selection is being dragged.
+            # make it the new selection.
+            self.unselect_all(signal=False)
+            self.select_path(path_info.path)
+            row_paths = [path_info.path]
+        rows = self.model.get_rows(row_paths)
+        self.drag_data = rows and self.drag_source.begin_drag(self, rows)
+        self.drag_button_down = bool(self.drag_data)
+        if self.drag_button_down:
+            self.drag_start_x = int(event.x)
+            self.drag_start_y = int(event.y)
+
+        if len(row_paths) > 1 and path_info.path in row_paths:
+            # handle multiple selection.  If the current row is already
+            # selected, stop propagating the signal.  We will only change
+            # the selection if the user doesn't start a DnD operation.
+            # This makes it more natural for the user to drag a block of
+            # selected items.
+            renderer = path_info.column.get_cell_renderers()[0]
+            if (not self._x_coord_in_expander(treeview, path_info)
+                    and not isinstance(renderer, GTKCheckboxCellRenderer)):
+                self.delaying_press = True
+                # grab keyboard focus since we handled the event
+                self.focus()
+                return True
+
+    def on_drag_data_get(self, treeview, context, selection, info, timestamp):
+        for typ, data in self.drag_data.items():
+            selection.set(typ, 8, repr(data))
+
+    def on_drag_end(self, treeview, context):
+        self.drag_data = {}
+
+    def find_type(self, drag_context):
+        return self._widget.drag_dest_find_target(drag_context,
+            self._widget.drag_dest_get_target_list())
+
+    def calc_positions(self, x, y):
+        """Given x and y coordinates, generate a list of drop positions to
+        try.  The values are tuples in the form of (parent_path, position,
+        gtk_path, gtk_position), where parent_path and position is the
+        position to send to the Miro code, and gtk_path and gtk_position is an
+        equivalent position to send to the GTK code if the drag_dest validates
+        the drop.
+        """
+        model = self._model
+        try:
+            gtk_path, gtk_position = self._widget.get_dest_row_at_pos(x, y)
+        except TypeError:
+            # Below the last row
+            yield (None, len(model), None, None)
+            return
+
+        iter_ = model.get_iter(gtk_path)
+        if gtk_position in (gtk.TREE_VIEW_DROP_INTO_OR_BEFORE,
+                gtk.TREE_VIEW_DROP_INTO_OR_AFTER):
+            yield (iter_, -1, gtk_path, gtk_position)
+
+        if hasattr(model, 'iter_is_valid'):
+            # tablist has this; item list does not
+            assert model.iter_is_valid(iter_)
+        parent_iter = model.iter_parent(iter_)
+        position = gtk_path[-1]
+        if gtk_position in (gtk.TREE_VIEW_DROP_BEFORE,
+                gtk.TREE_VIEW_DROP_INTO_OR_BEFORE):
+            # gtk gave us a "before" position, no need to change it
+            yield (parent_iter, position, gtk_path, gtk.TREE_VIEW_DROP_BEFORE)
+        else:
+            # gtk gave us an "after" position, translate that to before the
+            # next row for miro.
+            if (self._widget.row_expanded(gtk_path) and
+                    model.iter_has_child(iter_)):
+                child_path = gtk_path + (0,)
+                yield (iter_, 0, child_path, gtk.TREE_VIEW_DROP_BEFORE)
+            else:
+                yield (parent_iter, position+1, gtk_path,
+                        gtk.TREE_VIEW_DROP_AFTER)
+
+    def on_drag_motion(self, treeview, drag_context, x, y, timestamp):
+        if not self.drag_dest:
+            return True
+        type = self.find_type(drag_context)
+        if type == "NONE":
+            drag_context.drag_status(0, timestamp)
+            return True
+        drop_action = 0
+        for pos_info in self.calc_positions(x, y):
+            drop_action = self.drag_dest.validate_drop(self, self.model, type,
+                    drag_context.actions, pos_info[0], pos_info[1])
+            if isinstance(drop_action, (list, tuple)):
+                drop_action, iter = drop_action
+                path = self.model.get_path(iter)
+                pos = gtk.TREE_VIEW_DROP_INTO_OR_BEFORE
+            else:
+                path, pos = pos_info[2:4]
+
+            if drop_action:
+                self.set_drag_dest_row(path, pos)
+                break
+        else:
+            self.unset_drag_dest_row()
+        drag_context.drag_status(drop_action, timestamp)
+        return True
+
+    def set_drag_dest_row(self, path, position):
+        self._widget.set_drag_dest_row(path, position)
+
+    def unset_drag_dest_row(self):
+        self._widget.unset_drag_dest_row()
+
+    def on_drag_leave(self, treeview, drag_context, timestamp):
+        treeview.unset_drag_dest_row()
+
+    def on_drag_drop(self, treeview, drag_context, x, y, timestamp):
+        # prevent the default handler
+        treeview.emit_stop_by_name('drag-drop')
+        target = self.find_type(drag_context)
+        if target == "NONE":
+            return False
+        treeview.drag_get_data(drag_context, target, timestamp)
+        treeview.unset_drag_dest_row()
+
+    def on_drag_data_received(self,
+            treeview, drag_context, x, y, selection, info, timestamp):
+        # prevent the default handler
+        treeview.emit_stop_by_name('drag-data-received')
+        if not self.drag_dest:
+            return
+        type = self.find_type(drag_context)
+        if type == "NONE":
+            return
+        if selection.data is None:
+            return
+        drop_action = 0
+        for pos_info in self.calc_positions(x, y):
+            drop_action = self.drag_dest.validate_drop(self, self.model, type,
+                    drag_context.actions, pos_info[0], pos_info[1])
+            if drop_action:
+                self.drag_dest.accept_drop(self, self.model, type,
+                        drag_context.actions, pos_info[0], pos_info[1],
+                        eval(selection.data))
+                return True
+        return False
+
+    def on_drag_unrealize(self, treeview):
+        self.drag_button_down = False
+
+    def potential_drag_motion(self, treeview, event):
+        """A motion event has occurred and did not hit a hotspot; start a drag
+        if applicable.
+        """
+        if (self.drag_data and self.drag_button_down and
+                treeview.drag_check_threshold(self.drag_start_x,
+                    self.drag_start_y, int(event.x), int(event.y))):
+            self.delaying_press = False
+            treeview.drag_begin(self._gtk_target_list(self.drag_data.keys()),
+                    self.drag_source.allowed_actions(), 1, event)
+
+    @staticmethod
+    def _gtk_target_list(types):
+        count = itertools.count()
+        return [(type, gtk.TARGET_SAME_APP, count.next()) for type in types]
+
+class HotspotTrackingMixin(object):
+    def __init__(self):
+        self.hotspot_tracker = None
+        self.create_signal('hotspot-clicked')
+        self._hotspot_callback_handles = []
+        self._connect_hotspot_signals()
+        self.wrapped_widget_connect('unrealize', self.on_hotspot_unrealize)
+
+    def _connect_hotspot_signals(self):
+        SIGNALS = {
+            'row-inserted': self.on_row_inserted,
+            'row-deleted': self.on_row_deleted,
+            'row-changed': self.on_row_changed,
+        }
+        self._hotspot_callback_handles.extend(
+                weak_connect(self._model, signal, handler)
+                for signal, handler in SIGNALS.iteritems())
+
+    def _disconnect_hotspot_signals(self):
+        for handle in self._hotspot_callback_handles:
+            self._model.disconnect(handle)
+        self._hotspot_callback_handles = []
+
+    def on_row_inserted(self, model, path, iter_):
+        if self.hotspot_tracker:
+            self.hotspot_tracker.redraw_cell()
+            self.hotspot_tracker = None
+
+    def on_row_deleted(self, model, path):
+        if self.hotspot_tracker:
+            self.hotspot_tracker.redraw_cell()
+            self.hotspot_tracker = None
+
+    def on_row_changed(self, model, path, iter_):
+        if self.hotspot_tracker:
+            self.hotspot_tracker.update_hit()
+
+    def handle_hotspot_hit(self, treeview, event):
+        """Check whether the event is a hotspot event; return whether handled
+        here.
+        """
+        if self.hotspot_tracker:
+            return
+        hotspot_tracker = HotspotTracker(treeview, event)
+        if hotspot_tracker.hit:
+            self.hotspot_tracker = hotspot_tracker
+            hotspot_tracker.redraw_cell()
+            if hotspot_tracker.is_for_context_menu():
+                menu = self._popup_context_menu(self.hotspot_tracker.path, event)
+                if menu:
+                    menu.connect('selection-done',
+                            self._on_hotspot_context_menu_selection_done)
+            # grab keyboard focus since we handled the event
+            self.focus()
+            return True
+
+    def _on_hotspot_context_menu_selection_done(self, menu):
+        # context menu is closed, we won't get the button-release-event in
+        # this case, but we can unset hotspot tracker here.
+        if self.hotspot_tracker:
+            self.hotspot_tracker.redraw_cell()
+            self.hotspot_tracker = None
+
+    def on_hotspot_unrealize(self, treeview):
+        self.hotspot_tracker = None
+
+    def release_on_hotspot(self, event):
+        """A button_release occurred; return whether it has been handled as a
+        hotspot hit.
+        """
+        hotspot_tracker = self.hotspot_tracker
+        if hotspot_tracker and event.button == hotspot_tracker.button:
+            hotspot_tracker.update_position(event)
+            hotspot_tracker.update_hit()
+            if (hotspot_tracker.hit and
+                    not hotspot_tracker.is_for_context_menu()):
+                self.emit('hotspot-clicked', hotspot_tracker.name,
+                        hotspot_tracker.iter)
+            hotspot_tracker.redraw_cell()
+            self.hotspot_tracker = None
+            return True
+
+    def hotspot_model_changed(self):
+        """A bulk change has ended; reconnect signals and update hotspots."""
+        self._connect_hotspot_signals()
+        if self.hotspot_tracker:
+            self.hotspot_tracker.redraw_cell()
+            self.hotspot_tracker.update_hit()
+
+class ColumnOwnerMixin(object):
+    """Keeps track of the table's columns - including the list of columns, and
+    properties that we set for a table but need to apply to each column.
+
+    This manages:
+        columns
+        attr_map_for_column
+        gtk_column_to_wrapper
+    for use throughout tableview.
+    """
+    def __init__(self):
+        self._columns_draggable = False
+        self._renderer_xpad = self._renderer_ypad = 0
+        self.columns = []
+        self.attr_map_for_column = {}
+        self.gtk_column_to_wrapper = {}
+        self.create_signal('reallocate-columns') # not emitted on GTK
+
+    def remove_column(self, index):
+        """Remove a column from the display and forget it from the column lists.
+        """
+        column = self.columns.pop(index)
+        del self.attr_map_for_column[column._column]
+        del self.gtk_column_to_wrapper[column._column]
+        self._widget.remove_column(column._column)
+
+    def get_columns(self):
+        """Returns the current columns, in order, by title."""
+        # FIXME: this should probably return column objects, and really should
+        # not be keeping track of columns by title at all
+        titles = [column.get_title().decode('utf-8')
+                for column in self._widget.get_columns()]
+        return titles
+
+    def add_column(self, column):
+        """Append a column to this table; setup all necessary mappings, and
+        setup the new column's properties to match the table's settings.
+        """
+        self.model.check_new_column(column)
+        self._widget.append_column(column._column)
+        self.columns.append(column)
+        self.attr_map_for_column[column._column] = column.attrs
+        self.gtk_column_to_wrapper[column._column] = column
+        self.setup_new_column(column)
+
+    def setup_new_column(self, column):
+        """Apply properties that we keep track of at the table level to a
+        newly-created column.
+        """
+        if self.background_color:
+            column.renderer._renderer.set_property('cell-background-gdk',
+                    self.background_color)
+        column._column.set_reorderable(self._columns_draggable)
+        if column.do_horizontal_padding:
+            column.renderer._renderer.set_property('xpad', self._renderer_xpad)
+        column.renderer._renderer.set_property('ypad', self._renderer_ypad)
+
+    def set_column_spacing(self, space):
+        """Set the amount of space between columns."""
+        self._renderer_xpad = space / 2
+        for column in self.columns:
+            if column.do_horizontal_padding:
+                column.renderer._renderer.set_property('xpad',
+                                                       self._renderer_xpad)
+
+    def set_row_spacing(self, space):
+        """Set the amount of space between columns."""
+        self._renderer_ypad = space / 2
+        for column in self.columns:
+            column.renderer._renderer.set_property('ypad', self._renderer_ypad)
+
+    def set_columns_draggable(self, setting):
+        """Set the draggability of existing and future columns."""
+        self._columns_draggable = setting
+        for column in self.columns:
+            column._column.set_reorderable(setting)
+
+    def set_column_background_color(self):
+        """Set the background color of existing columns to the table's
+        background_color.
+        """
+        for column in self.columns:
+            column.renderer._renderer.set_property('cell-background-gdk',
+                    self.background_color)
+
+    def set_auto_resizes(self, setting):
+        # FIXME: to be implemented.
+        # At this point, GTK somehow does the right thing anyway in terms of
+        # auto-resizing.  I'm not sure exactly what's happening, but I believe
+        # that if the column widths don't add up to the total width,
+        # gtk.TreeView allocates extra width for the last column.  This works
+        # well enough for the tab list and item list, since there's only one
+        # column.
+        pass
+
+class HoverTrackingMixin(object):
+    """Handle mouse hover events - tooltips for some cells and hover events for
+    renderers which support them.
+    """
+    def __init__(self):
+        self.hover_info = None
+        self.hover_pos = None
+        if hasattr(self, 'get_tooltip'):
+            # this should probably be something like self.set_tooltip_source
+            self._widget.set_property('has-tooltip', True)
+            self.wrapped_widget_connect('query-tooltip', self.on_tooltip)
+            self._last_tooltip_place = None
+
+    def on_tooltip(self, treeview, x, y, keyboard_mode, tooltip):
+        # x, y are relative to the entire widget, but we want them to be
+        # relative to our bin window.  The bin window doesn't include things
+        # like the column headers.
+        origin = treeview.window.get_origin()
+        bin_origin = treeview.get_bin_window().get_origin()
+        x += origin[0] - bin_origin[0]
+        y += origin[1] - bin_origin[1]
+        path_info = treeview.get_position_info(x, y)
+        if path_info is None:
+            self._last_tooltip_place = None
+            return False
+        if (self._last_tooltip_place is not None and
+                path_info[:2] != self._last_tooltip_place):
+            # the default GTK behavior is to keep the tooltip in the same
+            # position, but this is looks bad when we move to a different row.
+            # So return False once to stop this.
+            self._last_tooltip_place = None
+            return False
+        self._last_tooltip_place = path_info[:2]
+        iter_ = treeview.get_model().get_iter(path_info.path)
+        column = self.gtk_column_to_wrapper[path_info.column]
+        text = self.get_tooltip(iter_, column)
+        if text is None:
+            return False
+        pygtkhacks.set_tooltip_text(tooltip, text)
+        return True
+
+    def _update_hover(self, treeview, event):
+        old_hover_info, old_hover_pos = self.hover_info, self.hover_pos
+        path_info = treeview.get_position_info(event.x, event.y)
+        if (path_info and
+                self.gtk_column_to_wrapper[path_info.column].renderer.want_hover):
+            self.hover_info = path_info.path, path_info.column
+            self.hover_pos = path_info.x, path_info.y
+        else:
+            self.hover_info = None
+            self.hover_pos = None
+        if (old_hover_info != self.hover_info or
+            old_hover_pos != self.hover_pos):
+            if (old_hover_info != self.hover_info and
+                old_hover_info is not None):
+                self._redraw_cell(treeview, *old_hover_info)
+            if self.hover_info is not None:
+                self._redraw_cell(treeview, *self.hover_info)
+
+class GTKScrollbarOwnerMixin(ScrollbarOwnerMixin):
+    # XXX this is half a wrapper for TreeViewScrolling. A lot of things will
+    # become much simpler when we integrate TVS into this
+    def __init__(self):
+        ScrollbarOwnerMixin.__init__(self)
+        # super uses this for postponed scroll_to_iter
+        # it's a faux-signal from our _widget; this hack is only necessary until
+        # we integrate TVS
+        self._widget.scroll_range_changed = (lambda *a:
+                self.emit('scroll-range-changed'))
+
+    def set_scroller(self, scroller):
+        """Set the Scroller object for this widget, if its ScrolledWindow is
+        not a direct ancestor of the object. Standard View needs this.
+        """
+        self._widget.set_scroller(scroller._widget)
+
+    def _set_scroll_position(self, scroll_pos):
+        self._widget.set_scroll_position(scroll_pos)
+
+    def _get_item_area(self, iter_):
+        return self._widget.get_path_rect(self.get_path(iter_))
+
+    @property
+    def _manually_scrolled(self):
+        return self._widget.manually_scrolled
+
+    @property
+    def _position_set(self):
+        return self._widget.position_set
+
+    def _get_visible_area(self):
+        """Return the Rect of the visible area, in tree coords.
+
+        get_visible_rect gets this wrong for StandardView, always returning an
+        origin of (0, 0) - this is because our ScrolledWindow is not our direct
+        parent.
+        """
+        bars = self._widget._scrollbars
+        x, y = (int(adj.get_value()) for adj in bars)
+        width, height = (int(adj.get_page_size()) for adj in bars)
+        if height == 0:
+            # this happens even after _widget._coords_working
+            raise WidgetNotReadyError('visible height')
+        return Rect(x, y, width, height)
+
+    def _get_scroll_position(self):
+        """Get the current position of both scrollbars, to restore later."""
+        try:
+            return tuple(int(bar.get_value()) for bar in self._widget._scrollbars)
+        except WidgetNotReadyError:
+            return None
+
+class TableView(Widget, GTKSelectionOwnerMixin, DNDHandlerMixin,
+        HotspotTrackingMixin, ColumnOwnerMixin, HoverTrackingMixin,
+        GTKScrollbarOwnerMixin):
+    """https://develop.participatoryculture.org/index.php/WidgetAPITableView"""
+
+    draws_selection = True
+
+    def __init__(self, model, custom_headers=False):
+        Widget.__init__(self)
+        self.set_widget(MiroTreeView())
+        self.model = model
+        self.model.add_to_tableview(self._widget)
+        self._model = self._widget.get_model()
+        wrappermap.add(self._model, model)
+        self._setup_colors()
+        self.background_color = None
+        self.context_menu_callback = None
+        self.in_bulk_change = False
+        self.delaying_press = False
+        self._use_custom_headers = False
+        self.layout_manager = LayoutManager(self._widget)
+        self.height_changed = None # 17178 hack
+        self._connect_signals()
+        # setting up mixins after general TableView init
+        GTKSelectionOwnerMixin.__init__(self)
+        DNDHandlerMixin.__init__(self)
+        HotspotTrackingMixin.__init__(self)
+        ColumnOwnerMixin.__init__(self)
+        HoverTrackingMixin.__init__(self)
+        GTKScrollbarOwnerMixin.__init__(self)
+        if custom_headers:
+            self._enable_custom_headers()
+
+    # FIXME: should implement set_model() and make None a special case.
+    def unset_model(self):
+        """Disconnect our model from this table view.
+
+        This should be called when you want to destroy a TableView and
+        there's a new TableView sharing its model.
+        """
+        self._widget.set_model(None)
+        self.model = None
+
+    def _connect_signals(self):
+        self.create_signal('row-expanded')
+        self.create_signal('row-collapsed')
+        self.create_signal('row-clicked')
+        self.create_signal('row-activated')
+        self.wrapped_widget_connect('row-activated', self.on_row_activated)
+        self.wrapped_widget_connect('row-expanded', self.on_row_expanded)
+        self.wrapped_widget_connect('row-collapsed', self.on_row_collapsed)
+        self.wrapped_widget_connect('button-press-event', self.on_button_press)
+        self.wrapped_widget_connect('button-release-event',
+            self.on_button_release)
+        self.wrapped_widget_connect('motion-notify-event',
+            self.on_motion_notify)
+
+    def set_gradient_highlight(self, gradient):
+        # This is just an OS X thing.
+        pass
+
+    def set_background_color(self, color):
+        self.background_color = self.make_color(color)
+        self.modify_style('base', gtk.STATE_NORMAL, self.background_color)
+        if not self.draws_selection:
+            self.modify_style('base', gtk.STATE_SELECTED,
+                              self.background_color)
+            self.modify_style('base', gtk.STATE_ACTIVE, self.background_color)
+        if self.use_custom_style:
+            self.set_column_background_color()
+
+    def set_group_lines_enabled(self, enabled):
+        """Enable/Disable group lines.
+
+        This only has an effect if our model is an InfoListModel and it has a
+        grouping set.
+
+        If group lines are enabled, we will draw a line below the last item in
+        the group.  Use set_group_line_style() to change the look of the line.
+        """
+        self._widget.group_lines_enabled = enabled
+        self.queue_redraw()
+
+    def set_group_line_style(self, color, width):
+        self._widget.group_line_color = color
+        self._widget.group_line_width = width
+        self.queue_redraw()
+
+    def handle_custom_style_change(self):
+        if self.background_color is not None:
+            if self.use_custom_style:
+                self.set_column_background_color()
+            else:
+                for column in self.columns:
+                    column.renderer._renderer.set_property(
+                            'cell-background-set', False)
+
+    def set_alternate_row_backgrounds(self, setting):
+        self._widget.set_rules_hint(setting)
+
+    def set_grid_lines(self, horizontal, vertical):
+        if horizontal and vertical:
+            setting = gtk.TREE_VIEW_GRID_LINES_BOTH
+        elif horizontal:
+            setting = gtk.TREE_VIEW_GRID_LINES_HORIZONTAL
+        elif vertical:
+            setting = gtk.TREE_VIEW_GRID_LINES_VERTICAL
+        else:
+            setting = gtk.TREE_VIEW_GRID_LINES_NONE
+        self._widget.set_grid_lines(setting)
+
+    def width_for_columns(self, total_width):
+        """Given the width allocated for the TableView, return how much of that
+        is available to column contents. Note that this depends on the number of
+        columns.
+        """
+        column_spacing = TableColumn.FIXED_PADDING * len(self.columns)
+        return total_width - column_spacing
+
+    def enable_album_view_focus_hack(self):
+        _install_album_view_gtkrc()
+        self._widget.set_name("miro-album-view")
+
+    def focus(self):
+        self._widget.grab_focus()
+
+    def _enable_custom_headers(self):
+        # NB: this is currently not used because the GTK tableview does not
+        # support custom headers.
+        self._use_custom_headers = True
+
+    def set_show_headers(self, show):
+        self._widget.set_headers_visible(show)
+        self._widget.set_headers_clickable(show)
+
+    def _setup_colors(self):
+        style = self._widget.style
+        if not self.draws_selection:
+            # if we don't want to draw selection, make the selected/active
+            # colors the same as the normal ones
+            self.modify_style('base', gtk.STATE_SELECTED,
+                style.base[gtk.STATE_NORMAL])
+            self.modify_style('base', gtk.STATE_ACTIVE,
+                style.base[gtk.STATE_NORMAL])
+
+    def set_search_column(self, model_index):
+        self._widget.set_search_column(model_index)
+
+    def set_fixed_height(self, fixed_height):
+        self._widget.set_fixed_height_mode(fixed_height)
+
+    def set_row_expanded(self, iter_, expanded):
+        """Expand or collapse the row specified by iter_. Succeeds or raises
+        WidgetActionError. Causes row-expanded or row-collapsed to be emitted
+        when successful.
+        """
+        path = self.get_path(iter_)
+        if expanded:
+            self._widget.expand_row(path, False)
+        else:
+            self._widget.collapse_row(path)
+        if bool(self._widget.row_expanded(path)) != bool(expanded):
+            raise WidgetActionError("cannot expand the given item - it "
+                    "probably has no children.")
+
+    def is_row_expanded(self, iter_):
+        path = self.get_path(iter_)
+        return self._widget.row_expanded(path)
+
+    def set_context_menu_callback(self, callback):
+        self.context_menu_callback = callback
+
+    # GTK is really good and it is safe to operate on table even when
+    # cells may be constantly changing in flux.
+    def set_volatile(self, volatile):
+        return
+
+    def on_row_expanded(self, _widget, iter_, path):
+        self.emit('row-expanded', iter_, path)
+
+    def on_row_collapsed(self, _widget, iter_, path):
+        self.emit('row-collapsed', iter_, path)
+
+    def on_button_press(self, treeview, event):
+        """Handle a mouse button press"""
+        if event.type == gtk.gdk._2BUTTON_PRESS:
+            # already handled as row-activated
+            return False
+
+        path_info = treeview.get_position_info(event.x, event.y)
+        if not path_info:
+            # no item was clicked, so it's not going to be a hotspot, drag, or
+            # context menu
+            return False
+        if event.type == gtk.gdk.BUTTON_PRESS:
+            # single click; emit the event but keep on running so we can handle
+            # stuff like drag and drop.
+            if not self._x_coord_in_expander(treeview, path_info):
+                iter_ = treeview.get_model().get_iter(path_info.path)
+                self.emit('row-clicked', iter_)
+
+        if (event.button == 1 and self.handle_hotspot_hit(treeview, event)):
+            return True
+        if event.window != treeview.get_bin_window():
+            # click is outside the content area, don't try to handle this.
+            # In particular, our DnD code messes up resizing table columns.
+            return False
+        if (event.button == 1 and self.drag_source and
+          not self._x_coord_in_expander(treeview, path_info)):
+            return self.start_drag(treeview, event, path_info)
+        elif event.button == 3 and self.context_menu_callback:
+            self.show_context_menu(treeview, event, path_info)
+            return True
+
+        # FALLTHROUGH
+        return False
+
+    def show_context_menu(self, treeview, event, path_info):
+        """Pop up a context menu for the given click event (which is a
+        right-click on a row).
+        """
+        # hack for album view
+        if (treeview.group_lines_enabled and
+            path_info.column == treeview.get_columns()[0]):
+            self._select_all_rows_in_group(treeview, path_info.path)
+        self._popup_context_menu(path_info.path, event)
+        # grab keyboard focus since we handled the event
+        self.focus()
+
+    def _select_all_rows_in_group(self, treeview, path):
+        """Select all items in the group """
+
+        # FIXME: this is very tightly coupled with the portable code.
+
+        infolist = self.model
+        gtk_model = treeview.get_model()
+        if (not isinstance(infolist, InfoListModel) or
+                infolist.get_grouping() is None):
+            return
+        it = gtk_model.get_iter(path)
+        info, attrs, group_info = infolist.row_for_iter(it)
+        start_row = path[0] - group_info[0]
+        total_rows = group_info[1]
+
+        with self._ignoring_changes():
+            self.unselect_all()
+            for row in xrange(start_row, start_row + total_rows):
+                self.select_path((row,))
+            self.emit('selection-changed')
+
+    def _popup_context_menu(self, path, event):
+        if not self.selection.path_is_selected(path):
+            self.unselect_all(signal=False)
+            self.select_path(path)
+        menu = self.make_context_menu()
+        if menu:
+            menu.popup(None, None, None, event.button, event.time)
+            return menu
+        else:
+            return None
+
+    # XXX treeview.get_cell_area handles what we're trying to use this for
+    def _x_coord_in_expander(self, treeview, path_info):
+        """Calculate if an x coordinate is over the expander triangle
+
+        :param treeview: Gtk.TreeView
+        :param path_info: PathInfo(
+            tree path for the cell,
+            Gtk.TreeColumn,
+            x coordinate relative to column's cell area,
+            y coordinate relative to column's cell area (ignored),
+        )
+        """
+        if path_info.column != treeview.get_expander_column():
+            return False
+        model = treeview.get_model()
+        if not model.iter_has_child(model.get_iter(path_info.path)):
+            return False
+        # GTK allocateds an extra 4px to the right of the expanders.  This
+        # seems to be hardcoded as EXPANDER_EXTRA_PADDING in the source code.
+        total_exander_size = treeview.expander_size + 4
+        # include horizontal_separator
+        # XXX: should this value be included in total_exander_size ?
+        offset = treeview.horizontal_separator / 2
+        # allocate space for expanders for parent nodes
+        expander_start = total_exander_size * (len(path_info.path) - 1) + offset
+        expander_end = expander_start + total_exander_size + offset
+        return expander_start <= path_info.x < expander_end
+
+    def on_row_activated(self, treeview, path, view_column):
+        iter_ = treeview.get_model().get_iter(path)
+        self.emit('row-activated', iter_)
+
+    def make_context_menu(self):
+        def gen_menu(menu_items):
+            menu = gtk.Menu()
+            for menu_item_info in menu_items:
+                if menu_item_info is None:
+                    item = gtk.SeparatorMenuItem()
+                else:
+                    label, callback = menu_item_info
+
+                    if isinstance(label, tuple) and len(label) == 2:
+                        text_label, icon_path = label
+                        pixbuf = gtk.gdk.pixbuf_new_from_file(icon_path)
+                        image = gtk.Image()
+                        image.set_from_pixbuf(pixbuf)
+                        item = gtk.ImageMenuItem(text_label)
+                        item.set_image(image)
+                    else:
+                        item = gtk.MenuItem(label)
+
+                    if callback is None:
+                        item.set_sensitive(False)
+                    elif isinstance(callback, list):
+                        item.set_submenu(gen_menu(callback))
+                    else:
+                        item.connect('activate', self.on_context_menu_activate,
+                                     callback)
+                menu.append(item)
+                item.show()
+            return menu
+
+        items = self.context_menu_callback(self)
+        if items:
+            return gen_menu(items)
+        else:
+            return None
+
+    def on_context_menu_activate(self, item, callback):
+        callback()
+
+    def on_button_release(self, treeview, event):
+        if self.release_on_hotspot(event):
+            return True
+        if event.button == 1:
+            self.drag_button_down = False
+
+            if self.delaying_press:
+                # if dragging did not happen, unselect other rows and
+                # select current row
+                path_info = treeview.get_position_info(event.x, event.y)
+                if path_info is not None:
+                    self.unselect_all(signal=False)
+                    self.select_path(path_info.path)
+        self.delaying_press = False
+
+    def _redraw_cell(self, treeview, path, column):
+        cell_area = treeview.get_cell_area(path, column)
+        x, y = treeview.convert_bin_window_to_widget_coords(cell_area.x,
+                                                            cell_area.y)
+        treeview.queue_draw_area(x, y, cell_area.width, cell_area.height)
+
+    def on_motion_notify(self, treeview, event):
+        self._update_hover(treeview, event)
+
+        if self.hotspot_tracker:
+            self.hotspot_tracker.update_position(event)
+            self.hotspot_tracker.update_hit()
+            return True
+
+        self.potential_drag_motion(treeview, event)
+        return None # XXX: used to fall through; not sure what retval does here
+
+    def start_bulk_change(self):
+        self._widget.freeze_child_notify()
+        self._widget.set_model(None)
+        self._disconnect_hotspot_signals()
+        self.in_bulk_change = True
+
+    def model_changed(self):
+        if self.in_bulk_change:
+            self._widget.set_model(self._model)
+            self._widget.thaw_child_notify()
+            self.hotspot_model_changed()
+            self.in_bulk_change = False
+
+    def get_path(self, iter_):
+        """Always use this rather than the model's get_path directly -
+        if the iter isn't valid, a GTK assertion causes us to exit
+        without warning; this wrapper changes that to a much more useful
+        AssertionError. Example related bug: #17362.
+        """
+        assert self.model.iter_is_valid(iter_)
+        return self._model.get_path(iter_)
+
+class TableModel(object):
+    """https://develop.participatoryculture.org/index.php/WidgetAPITableView"""
+    MODEL_CLASS = gtk.ListStore
+
+    def __init__(self, *column_types):
+        self._model = self.MODEL_CLASS(*self.map_types(column_types))
+        self._column_types = column_types
+        if 'image' in self._column_types:
+            self.convert_row_for_gtk = self.convert_row_for_gtk_slow
+            self.convert_value_for_gtk = self.convert_value_for_gtk_slow
+        else:
+            self.convert_row_for_gtk = self.convert_row_for_gtk_fast
+            self.convert_value_for_gtk = self.convert_value_for_gtk_fast
+
+    def add_to_tableview(self, widget):
+        widget.set_model(self._model)
+
+    def map_types(self, miro_column_types):
+        type_map = {
+                'boolean': bool,
+                'numeric': float,
+                'integer': int,
+                'text': str,
+                'image': gtk.gdk.Pixbuf,
+                'datetime': object,
+                'object': object,
+        }
+        try:
+            return [type_map[type] for type in miro_column_types]
+        except KeyError, e:
+            raise ValueError("Unknown column type: %s" % e[0])
+
+    # If we store image data, we need to do some work to convert row data to
+    # send to GTK
+    def convert_value_for_gtk_slow(self, column_value):
+        if isinstance(column_value, Image):
+            return column_value.pixbuf
+        else:
+            return column_value
+
+    def convert_row_for_gtk_slow(self, column_values):
+        return tuple(self.convert_value_for_gtk(c) for c in column_values)
+
+    def check_new_column(self, column):
+        for value in column.attrs.values():
+            if not isinstance(value, int):
+                msg = "Attribute values must be integers, not %r" % value
+                raise TypeError(msg)
+            if value < 0 or value >= len(self._column_types):
+                raise ValueError("Attribute index out of range: %s" % value)
+
+    # If we don't store image data, we can don't need to do any work to
+    # convert row data to gtk
+    def convert_value_for_gtk_fast(self, value):
+        return value
+
+    def convert_row_for_gtk_fast(self, column_values):
+        return column_values
+
+    def append(self, *column_values):
+        return self._model.append(self.convert_row_for_gtk(column_values))
+
+    def update_value(self, iter_, index, value):
+        assert self._model.iter_is_valid(iter_)
+        self._model.set(iter_, index, self.convert_value_for_gtk(value))
+
+    def update(self, iter_, *column_values):
+        self._model[iter_] = self.convert_value_for_gtk(column_values)
+
+    def remove(self, iter_):
+        if self._model.remove(iter_):
+            return iter_
+        else:
+            return None
+
+    def insert_before(self, iter_, *column_values):
+        row = self.convert_row_for_gtk(column_values)
+        return self._model.insert_before(iter_, row)
+
+    def first_iter(self):
+        return self._model.get_iter_first()
+
+    def next_iter(self, iter_):
+        return self._model.iter_next(iter_)
+
+    def nth_iter(self, index):
+        assert index >= 0
+        return self._model.iter_nth_child(None, index)
+
+    def __iter__(self):
+        return iter(self._model)
+
+    def __len__(self):
+        return len(self._model)
+
+    def __getitem__(self, iter_):
+        return self._model[iter_]
+
+    def get_rows(self, row_paths):
+        return [self._model[path] for path in row_paths]
+
+    def get_path(self, iter_):
+        return self._model.get_path(iter_)
+
+    def iter_is_valid(self, iter_):
+        return self._model.iter_is_valid(iter_)
+
+class TreeTableModel(TableModel):
+    """https://develop.participatoryculture.org/index.php/WidgetAPITableView"""
+    MODEL_CLASS = gtk.TreeStore
+
+    def append(self, *column_values):
+        return self._model.append(None, self.convert_row_for_gtk(
+            column_values))
+
+    def insert_before(self, iter_, *column_values):
+        parent = self.parent_iter(iter_)
+        row = self.convert_row_for_gtk(column_values)
+        return self._model.insert_before(parent, iter_, row)
+
+    def append_child(self, iter_, *column_values):
+        return self._model.append(iter_, self.convert_row_for_gtk(
+            column_values))
+
+    def child_iter(self, iter_):
+        return self._model.iter_children(iter_)
+
+    def nth_child_iter(self, iter_, index):
+        assert index >= 0
+        return self._model.iter_nth_child(iter_, index)
+
+    def has_child(self, iter_):
+        return self._model.iter_has_child(iter_)
+
+    def children_count(self, iter_):
+        return self._model.iter_n_children(iter_)
+
+    def parent_iter(self, iter_):
+        assert self._model.iter_is_valid(iter_)
+        return self._model.iter_parent(iter_)
diff --git a/lvc/widgets/gtk/tableviewcells.py b/lvc/widgets/gtk/tableviewcells.py
new file mode 100644
index 0000000..6511970
--- /dev/null
+++ b/lvc/widgets/gtk/tableviewcells.py
@@ -0,0 +1,249 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""tableviewcells.py - Cell renderers for TableView."""
+
+import gobject
+import gtk
+import pango
+
+from lvc import signals
+from lvc.widgets import widgetconst
+import drawing
+import wrappermap
+from .base import make_gdk_color
+
+class CellRenderer(object):
+    """Simple Cell Renderer
+    https://develop.participatoryculture.org/index.php/WidgetAPITableView"""
+    def __init__(self):
+        self._renderer = gtk.CellRendererText()
+        self.want_hover = False
+
+    def setup_attributes(self, column, attr_map):
+        column.add_attribute(self._renderer, 'text', attr_map['value'])
+
+    def set_align(self, align):
+        if align == 'left':
+            self._renderer.props.xalign = 0.0
+        elif align == 'center':
+            self._renderer.props.xalign = 0.5
+        elif align == 'right':
+            self._renderer.props.xalign = 1.0
+        else:
+            raise ValueError("unknown alignment: %s" % align)
+
+    def set_color(self, color):
+        self._renderer.props.foreground_gdk = make_gdk_color(color)
+
+    def set_bold(self, bold):
+        font_desc = self._renderer.props.font_desc
+        if bold:
+            font_desc.set_weight(pango.WEIGHT_BOLD)
+        else:
+            font_desc.set_weight(pango.WEIGHT_NORMAL)
+        self._renderer.props.font_desc = font_desc
+
+    def set_text_size(self, size):
+        if size == widgetconst.SIZE_NORMAL:
+            self._renderer.props.scale = 1.0
+        elif size == widgetconst.SIZE_SMALL:
+            # FIXME: on 3.5 we just ignored the call.  Always setting scale to
+            # 1.0 basically replicates that behavior, but should we actually
+            # try to implement the semantics of SIZE_SMALL?
+            self._renderer.props.scale = 1.0
+        else:
+            raise ValueError("unknown size: %s" % size)
+
+    def set_font_scale(self, scale_factor):
+        self._renderer.props.scale = scale_factor
+
+class ImageCellRenderer(object):
+    """Cell Renderer for images
+    https://develop.participatoryculture.org/index.php/WidgetAPITableView"""
+    def __init__(self):
+        self._renderer = gtk.CellRendererPixbuf()
+        self.want_hover = False
+
+    def setup_attributes(self, column, attr_map):
+        column.add_attribute(self._renderer, 'pixbuf', attr_map['image'])
+
+class GTKCheckboxCellRenderer(gtk.CellRendererToggle):
+    def do_activate(self, event, treeview, path, background_area, cell_area,
+            flags):
+        iter = treeview.get_model().get_iter(path)
+        self.set_active(not self.get_active())
+        wrappermap.wrapper(self).emit('clicked', iter)
+
+gobject.type_register(GTKCheckboxCellRenderer)
+
+class CheckboxCellRenderer(signals.SignalEmitter):
+    """Cell Renderer for booleans
+    https://develop.participatoryculture.org/index.php/WidgetAPITableView"""
+    def __init__(self):
+        signals.SignalEmitter.__init__(self)
+        self.create_signal("clicked")
+        self._renderer = GTKCheckboxCellRenderer()
+        wrappermap.add(self._renderer, self)
+        self.want_hover = False
+
+    def set_control_size(self, size):
+        pass
+
+    def setup_attributes(self, column, attr_map):
+        column.add_attribute(self._renderer, 'active', attr_map['value'])
+
+class GTKCustomCellRenderer(gtk.GenericCellRenderer):
+    """Handles the GTK hide of CustomCellRenderer
+    https://develop.participatoryculture.org/index.php/WidgetAPITableView"""
+
+    def on_get_size(self, widget, cell_area=None):
+        wrapper = wrappermap.wrapper(self)
+        widget_wrapper = wrappermap.wrapper(widget)
+        style = drawing.DrawingStyle(widget_wrapper, use_base_color=True)
+        # NOTE: CustomCellRenderer.cell_data_func() sets up its attributes
+        # from the model itself, so we don't have to worry about setting them
+        # here.
+        width, height = wrapper.get_size(style, widget_wrapper.layout_manager)
+        x_offset = self.props.xpad
+        y_offset = self.props.ypad
+        width += self.props.xpad * 2
+        height += self.props.ypad * 2
+        if cell_area:
+            x_offset += cell_area.x
+            y_offset += cell_area.x
+            extra_width = max(0, cell_area.width - width)
+            extra_height = max(0, cell_area.height - height)
+            x_offset += int(round(self.props.xalign * extra_width))
+            y_offset += int(round(self.props.yalign * extra_height))
+        return x_offset, y_offset, width, height
+
+    def on_render(self, window, widget, background_area, cell_area, expose_area,
+            flags):
+        widget_wrapper = wrappermap.wrapper(widget)
+        cell_wrapper = wrappermap.wrapper(self)
+
+        selected = (flags & gtk.CELL_RENDERER_SELECTED)
+        if selected:
+            if widget.flags() & gtk.HAS_FOCUS:
+                state = gtk.STATE_SELECTED
+            else:
+                state = gtk.STATE_ACTIVE
+        else:
+            state = gtk.STATE_NORMAL
+        if cell_wrapper.IGNORE_PADDING:
+            area = background_area
+        else:
+            xpad = self.props.xpad
+            ypad = self.props.ypad
+            area = gtk.gdk.Rectangle(cell_area.x + xpad, cell_area.y + ypad,
+                    cell_area.width - xpad * 2, cell_area.height - ypad * 2)
+        context = drawing.DrawingContext(window, area, expose_area)
+        if (selected and not widget_wrapper.draws_selection and
+                widget_wrapper.use_custom_style):
+            # Draw the base color as our background.  This erases the gradient
+            # that GTK draws for selected items.
+            window.draw_rectangle(widget.style.base_gc[state], True,
+                    background_area.x, background_area.y,
+                    background_area.width, background_area.height)
+        context.style = drawing.DrawingStyle(widget_wrapper,
+                use_base_color=True, state=state)
+        widget_wrapper.layout_manager.update_cairo_context(context.context)
+        hotspot_tracker = widget_wrapper.hotspot_tracker
+        if (hotspot_tracker and hotspot_tracker.hit and
+                hotspot_tracker.column == self.column and
+                hotspot_tracker.path == self.path):
+            hotspot = hotspot_tracker.name
+        else:
+            hotspot = None
+        if (self.path, self.column) == widget_wrapper.hover_info:
+            hover = widget_wrapper.hover_pos
+            hover = (hover[0] - xpad, hover[1] - ypad)
+        else:
+            hover = None
+        # NOTE: CustomCellRenderer.cell_data_func() sets up its attributes
+        # from the model itself, so we don't have to worry about setting them
+        # here.
+        widget_wrapper.layout_manager.reset()
+        cell_wrapper.render(context, widget_wrapper.layout_manager, selected,
+                hotspot, hover)
+
+    def on_activate(self, event, widget, path, background_area, cell_area,
+            flags):
+        pass
+
+    def on_start_editing(self, event, widget, path, background_area,
+            cell_area, flags):
+        pass
+gobject.type_register(GTKCustomCellRenderer)
+
+class CustomCellRenderer(object):
+    """Customizable Cell Renderer
+    https://develop.participatoryculture.org/index.php/WidgetAPITableView"""
+
+    IGNORE_PADDING = False
+
+    def __init__(self):
+        self._renderer = GTKCustomCellRenderer()
+        self.want_hover = False
+        wrappermap.add(self._renderer, self)
+
+    def setup_attributes(self, column, attr_map):
+        column.set_cell_data_func(self._renderer, self.cell_data_func,
+                attr_map)
+
+    def cell_data_func(self, column, cell, model, iter, attr_map):
+        cell.column = column
+        cell.path = model.get_path(iter)
+        row = model[iter]
+        # Set attributes on self instead cell This works because cell is just
+        # going to turn around and call our methods to do the rendering.
+        for name, index in attr_map.items():
+            setattr(self, name, row[index])
+
+    def hotspot_test(self, style, layout, x, y, width, height):
+        return None
+
+class InfoListRenderer(CustomCellRenderer):
+    """Custom Renderer for InfoListModels
+    https://develop.participatoryculture.org/index.php/WidgetAPITableView"""
+
+    def cell_data_func(self, column, cell, model, iter, attr_map):
+        self.info, self.attrs, self.group_info = \
+                wrappermap.wrapper(model).row_for_iter(iter)
+        cell.column = column
+        cell.path = model.get_path(iter)
+
+class InfoListRendererText(CellRenderer):
+    """Renderer for InfoListModels that only display text
+    https://develop.participatoryculture.org/index.php/WidgetAPITableView"""
+
+    def setup_attributes(self, column, attr_map):
+        infolist.gtk.setup_text_cell_data_func(column, self._renderer,
+                self.get_value)
diff --git a/lvc/widgets/gtk/weakconnect.py b/lvc/widgets/gtk/weakconnect.py
new file mode 100644
index 0000000..204a855
--- /dev/null
+++ b/lvc/widgets/gtk/weakconnect.py
@@ -0,0 +1,56 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""weakconnect.py -- Connect to a signal of a GObject using a weak method
+reference.  This means that this connection will not keep the object alive.
+This is a good thing because it prevents circular references between wrapper
+widgets and the wrapped GTK widget.
+"""
+
+from lvc import signals
+
+class WeakSignalHandler(object):
+    def __init__(self, method):
+        self.method = signals.WeakMethodReference(method)
+
+    def connect(self, obj, signal, *user_args):
+        self.user_args = user_args
+        self.signal_handle = obj.connect(signal, self.handle_callback)
+        return self.signal_handle
+
+    def handle_callback(self, obj, *args):
+        real_method = self.method()
+        if real_method is not None:
+            return real_method(obj, *(args + self.user_args))
+        else:
+            obj.disconnect(self.signal_handle)
+
+def weak_connect(gobject, signal, method, *user_args):
+    handler = WeakSignalHandler(method)
+    return handler.connect(gobject, signal, *user_args)
diff --git a/lvc/widgets/gtk/widgets.py b/lvc/widgets/gtk/widgets.py
new file mode 100644
index 0000000..6c4280d
--- /dev/null
+++ b/lvc/widgets/gtk/widgets.py
@@ -0,0 +1,47 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".widgets -- Contains portable implementations of
+the GTK Widgets.  These are shared between the windows port and the x11 port.
+"""
+
+import gtk
+
+# Just use the GDK Rectangle class
+class Rect(gtk.gdk.Rectangle):
+    @classmethod
+    def from_string(cls, rect_string):
+        x, y, width, height = [int(i) for i in rect_string.split(',')]
+        return Rect(x, y, width, height)
+
+    def __str__(self):
+        return "%d,%d,%d,%d" % (self.x, self.y, self.width, self.height)
+
+    def get_width(self):
+        return self.width
diff --git a/lvc/widgets/gtk/widgetset.py b/lvc/widgets/gtk/widgetset.py
new file mode 100644
index 0000000..c63855c
--- /dev/null
+++ b/lvc/widgets/gtk/widgetset.py
@@ -0,0 +1,63 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+from .base import Widget, Bin
+from .const import *
+from .controls import TextEntry, NumberEntry, \
+     SecureTextEntry, MultilineTextEntry, Checkbox, RadioButton, \
+     RadioButtonGroup, OptionMenu, Button
+from .customcontrols import (
+    CustomButton, DragableCustomButton, CustomSlider,
+    ClickableImageButton)
+# VolumeSlider and VolumeMuter aren't defined if gtk.VolumeButton
+# doesn't have get_popup.
+try:
+    from .customcontrols import (
+        VolumeSlider, VolumeMuter)
+except ImportError:
+    pass
+from .contextmenu import ContextMenu
+from .drawing import ImageSurface, DrawingContext, \
+     DrawingArea, Background, Gradient
+from .layout import HBox, VBox, Alignment, \
+     Splitter, Table, TabContainer, DetachedWindowHolder
+from .window import Window, MainWindow, Dialog, \
+     FileOpenDialog, FileSaveDialog, DirectorySelectDialog, AboutDialog, \
+     AlertDialog, DialogWindow
+from .tableview import (TableView, TableModel,
+        TableColumn, TreeTableModel, CUSTOM_HEADER_HEIGHT)
+from .tableviewcells import (CellRenderer,
+        ImageCellRenderer, CheckboxCellRenderer, CustomCellRenderer,
+        InfoListRenderer, InfoListRendererText)
+from .simple import (Image, ImageDisplay,
+        AnimatedImageDisplay, Label, Scroller, Expander, SolidBackground,
+        ProgressBar, HLine)
+from .widgets import Rect
+from .gtkmenus import (MenuItem, RadioMenuItem, CheckMenuItem, Separator,
+        Menu, MenuBar, MainWindowMenuBar)
diff --git a/lvc/widgets/gtk/window.py b/lvc/widgets/gtk/window.py
new file mode 100644
index 0000000..de912cc
--- /dev/null
+++ b/lvc/widgets/gtk/window.py
@@ -0,0 +1,708 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Jesus Eduardo (Heckyel) | 2017
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".window -- GTK Window widget."""
+
+import gobject
+import gtk
+import os
+
+from lvc import resources
+from lvc import signals
+
+import keymap
+import layout
+import widgets
+import wrappermap
+
+# keeps the objects alive until destroy() is called
+alive_windows = set()
+running_dialogs = set()
+
+class WrappedWindow(gtk.Window):
+    def do_map(self):
+        gtk.Window.do_map(self)
+        wrappermap.wrapper(self).emit('show')
+
+    def do_unmap(self):
+        gtk.Window.do_unmap(self)
+        wrappermap.wrapper(self).emit('hide')
+    def do_focus_in_event(self, event):
+        gtk.Window.do_focus_in_event(self, event)
+        wrappermap.wrapper(self).emit('active-change')
+    def do_focus_out_event(self, event):
+        gtk.Window.do_focus_out_event(self, event)
+        wrappermap.wrapper(self).emit('active-change')
+
+    def do_key_press_event(self, event):
+        if self.activate_key(event): # event activated a menu item
+            return
+
+        if self.propagate_key_event(event): # event handled by widget
+            return
+
+        ret = keymap.translate_gtk_event(event)
+        if ret is not None:
+            key, modifiers = ret
+            rv = wrappermap.wrapper(self).emit('key-press', key, modifiers)
+            if not rv:
+                gtk.Window.do_key_press_event(self, event)
+
+    def _get_focused_wrapper(self):
+        """Get the wrapper of the widget with keyboard focus"""
+        focused = self.get_focus()
+        # some of our widgets created children for their use
+        # (GtkSearchTextEntry).  If we don't find a wrapper for
+        # focused, try it's parents
+        while focused is not None:
+            try:
+                wrapper = wrappermap.wrapper(focused)
+            except KeyError:
+                focused = focused.get_parent()
+            else:
+                return wrapper
+        return None
+
+    def change_focus_using_wrapper(self, direction):
+        my_wrapper = wrappermap.wrapper(self)
+        focused_wrapper = self._get_focused_wrapper()
+        if direction == gtk.DIR_TAB_FORWARD:
+            to_focus = my_wrapper.get_next_tab_focus(focused_wrapper, True)
+        elif direction == gtk.DIR_TAB_BACKWARD:
+            to_focus = my_wrapper.get_next_tab_focus(focused_wrapper, False)
+        else:
+            return False
+        if to_focus is not None:
+            to_focus.focus()
+            return True
+        return False
+
+    def do_focus(self, direction):
+        if not self.change_focus_using_wrapper(direction):
+            gtk.Window.do_focus(self, direction)
+
+gobject.type_register(WrappedWindow)
+
+class WindowBase(signals.SignalEmitter):
+    def __init__(self):
+        signals.SignalEmitter.__init__(self)
+        self.create_signal('use-custom-style-changed')
+        self.create_signal('key-press')
+        self.create_signal('show')
+        self.create_signal('hide')
+
+    def set_window(self, window):
+        self._window = window
+        window.connect('style-set', self.on_style_set)
+        wrappermap.add(window, self)
+        self.calc_use_custom_style()
+
+    def on_style_set(self, widget, old_style):
+        old_use_custom_style = self.use_custom_style
+        self.calc_use_custom_style()
+        if old_use_custom_style != self.use_custom_style:
+            self.emit('use-custom-style-changed')
+
+    def calc_use_custom_style(self):
+        if self._window is not None:
+            base = self._window.style.base[gtk.STATE_NORMAL]
+            # Decide if we should use a custom style.  Right now the
+            # formula is the base color is a very light shade of
+            # gray/white (lighter than #f0f0f0).
+            self.use_custom_style = ((base.red == base.green == base.blue) and
+                                     base.red >= 61680)
+
+
+class Window(WindowBase):
+    """The main Libre window.  """
+
+    def __init__(self, title, rect=None):
+        """Create the Libre Main Window.  Title is the name to give the
+        window, rect specifies the position it should have on screen.
+        """
+        WindowBase.__init__(self)
+        self.set_window(self._make_gtk_window())
+        self._window.set_title(title)
+        self.setup_icon()
+        if rect:
+            self._window.set_default_size(rect.width, rect.height)
+            self._window.set_default_size(rect.width, rect.height)
+            self._window.set_gravity(gtk.gdk.GRAVITY_CENTER)
+            self._window.move(rect.x, rect.y)
+
+        self.create_signal('active-change')
+        self.create_signal('will-close')
+        self.create_signal('did-move')
+        self.create_signal('file-drag-motion')
+        self.create_signal('file-drag-received')
+        self.create_signal('file-drag-leave')
+        self.create_signal('on-shown')
+        self.drag_signals = []
+        alive_windows.add(self)
+
+        self._window.connect('delete-event', self.on_delete_window)
+        self._window.connect('map-event', lambda w, a: self.emit('on-shown'))
+        # XXX: Define MVCWindow/MiroWindow style not hard code this
+        self._window.set_resizable(False)
+
+    def setup_icon(self):
+        icon_pixbuf = gtk.gdk.pixbuf_new_from_file(
+                resources.image_path("lvc-logo.png"))
+        self._window.set_icon(icon_pixbuf)
+
+
+    def accept_file_drag(self, val):
+        if not val:
+            self._window.drag_dest_set(0, [], 0)
+            for handle in self.drag_signals:
+                self.disconnect(handle)
+            self.drag_signals = []
+        else:
+            self._window.drag_dest_set(
+                gtk.DEST_DEFAULT_MOTION | gtk.DEST_DEFAULT_DROP,
+                [('text/uri-list', 0, 0)],
+                gtk.gdk.ACTION_COPY)
+            for signal, callback in (
+                ('drag-motion', self.on_drag_motion),
+                ('drag-data-received', self.on_drag_data_received),
+                ('drag-leave', self.on_drag_leave)):
+                self.drag_signals.append(
+                    self._window.connect(signal, callback))
+
+    def on_drag_motion(self, widget, context, x, y, time):
+        self.emit('file-drag-motion')
+
+    def on_drag_data_received(self, widget, context, x, y, selection_data,
+                              info, time):
+        self.emit('file-drag-received', selection_data.get_uris())
+
+    def on_drag_leave(self, widget, context, time):
+        self.emit('file-drag-leave')
+
+    def on_delete_window(self, widget, event):
+        # when the user clicks on the X in the corner of the window we
+        # want that to close the window, but also trigger our
+        # will-close signal and all that machinery unless the window
+        # is currently hidden--then we don't do anything.
+        if not self._window.window.is_visible():
+            return
+        self.close()
+        return True
+
+    def _make_gtk_window(self):
+        return WrappedWindow()
+
+    def set_title(self, title):
+        self._window.set_title(title)
+
+    def get_title(self):
+        self._window.get_title()
+
+    def center(self):
+        self._window.set_position(gtk.WIN_POS_CENTER)
+
+    def show(self):
+        if self not in alive_windows:
+            raise ValueError("Window destroyed")
+        self._window.show()
+
+    def close(self):
+        if hasattr(self, "_closing"):
+            return
+        self._closing = True
+        # Keep a reference to the widget in case will-close signal handler
+        # calls destroy()
+        old_window = self._window
+        self.emit('will-close')
+        old_window.hide()
+        del self._closing
+
+    def destroy(self):
+        self.close()
+        self._window = None
+        alive_windows.discard(self)
+
+    def is_active(self):
+        return self._window.is_active()
+
+    def is_visible(self):
+        return self._window.props.visible
+
+    def get_next_tab_focus(self, current, is_forward):
+        return None
+
+    def set_content_widget(self, widget):
+        """Set the widget that will be drawn in the content area for this
+        window.
+
+        It will be allocated the entire area of the widget, except the
+        space needed for the titlebar, frame and other decorations.
+        When the window is resized, content should also be resized.
+        """
+        self._add_content_widget(widget)
+        widget._widget.show()
+        self.content_widget = widget
+
+    def _add_content_widget(self, widget):
+        self._window.add(widget._widget)
+
+    def get_content_widget(self, widget):
+        """Get the current content widget."""
+        return self.content_widget
+
+    def get_frame(self):
+        pos = self._window.get_position()
+        size = self._window.get_size()
+        return widgets.Rect(pos[0], pos[1], size[0], size[1])
+
+    def set_frame(self, x=None, y=None, width=None, height=None):
+        if x is not None or y is not None:
+            pos = self._window.get_position()
+            x = x if x is not None else pos[0]
+            y = y if y is not None else pos[1]
+            self._window.move(x, y)
+
+        if width is not None or height is not None:
+            size = self._window.get_size()
+            width = width if width is not None else size[0]
+            height = height if height is not None else size[1]
+            self._window.resize(width, height)
+
+    def get_monitor_geometry(self):
+        """Returns a Rect of the geometry of the monitor that this
+        window is currently on.
+
+        :returns: Rect
+        """
+        gtkwindow = self._window
+        gdkwindow = gtkwindow.window
+        screen = gtkwindow.get_screen()
+
+        monitor = screen.get_monitor_at_window(gdkwindow)
+        return screen.get_monitor_geometry(monitor)
+
+    def check_position_and_fix(self):
+        """This pulls the geometry of the monitor of the screen this
+        window is on as well as the position of the window.
+
+        It then makes sure that the position y is greater than the
+        monitor geometry y.  This makes sure that the titlebar of
+        the window is showing.
+        """
+        gtkwindow = self._window
+        gdkwindow = gtkwindow.window
+        monitor_geom = self.get_monitor_geometry()
+
+        frame_extents = gdkwindow.get_frame_extents()
+        position = gtkwindow.get_position()
+
+        # if the frame is not visible, then we move the window so that
+        # it is
+        if frame_extents.y < monitor_geom.y:
+            gtkwindow.move(position[0],
+                           monitor_geom.y + (position[1] - frame_extents.y))
+
+
+
+class DialogWindow(Window):
+    def __init__(self, title, rect=None):
+        Window.__init__(self, title, rect)
+        self._window.set_resizable(False)
+
+class MainWindow(Window):
+    def __init__(self, title, rect):
+        Window.__init__(self, title, rect)
+        self.vbox = gtk.VBox()
+        self._window.add(self.vbox)
+        self.vbox.show()
+        self._add_app_menubar()
+        self.create_signal('save-dimensions')
+        self.create_signal('save-maximized')
+        self._window.connect('key-release-event', self.on_key_release)
+        self._window.connect('window-state-event', self.on_window_state_event)
+        self._window.connect('configure-event', self.on_configure_event)
+
+    def _make_gtk_window(self):
+        return WrappedWindow()
+
+    def on_delete_window(self, widget, event):
+        return True
+
+    def on_configure_event(self, widget, event):
+        (x, y) = self._window.get_position()
+        (width, height) = self._window.get_size()
+        self.emit('save-dimensions', x, y, width, height)
+
+    def on_window_state_event(self, widget, event):
+        maximized = bool(
+            event.new_window_state & gtk.gdk.WINDOW_STATE_MAXIMIZED)
+        self.emit('save-maximized', maximized)
+
+    def on_key_release(self, widget, event):
+        if app.playback_manager.is_playing:
+            if gtk.gdk.keyval_name(event.keyval) in ('Right', 'Left',
+                                                     'Up', 'Down'):
+                return True
+
+    def _add_app_menubar(self):
+        self.menubar = app.widgetapp.menubar
+        self.vbox.pack_start(self.menubar._widget, expand=False)
+        self.connect_menu_keyboard_shortcuts()
+
+    def _add_content_widget(self, widget):
+        self.vbox.pack_start(widget._widget, expand=True)
+
+
+class DialogBase(WindowBase):
+    def set_transient_for(self, window):
+        self._window.set_transient_for(window._window)
+
+    def run(self):
+        running_dialogs.add(self)
+        try:
+            return self._run()
+        finally:
+            running_dialogs.remove(self)
+            self._window = None
+
+    def _run(self):
+        """Run the dialog.  Must be implemented by subclasses."""
+        raise NotImplementedError()
+
+    def destroy(self):
+        if self._window is not None:
+            self._window.response(gtk.RESPONSE_NONE)
+            # don't set self._window to None yet.  We will unset it when we
+            # return from the _run() method
+
+class Dialog(DialogBase):
+    def __init__(self, title, description=None):
+        """Create a dialog."""
+        DialogBase.__init__(self)
+        self.create_signal('open')
+        self.create_signal('close')
+        self.set_window(gtk.Dialog(title))
+        self._window.set_default_size(425, -1)
+        self.extra_widget = None
+        self.buttons_to_add = []
+        wrappermap.add(self._window, self)
+        self.description = description
+
+    def build_content(self):
+        packing_vbox = layout.VBox(spacing=20)
+        packing_vbox._widget.set_border_width(6)
+        if self.description is not None:
+            label = gtk.Label(self.description)
+            label.set_line_wrap(True)
+            label.set_size_request(390, -1)
+            label.set_selectable(True)
+            packing_vbox._widget.pack_start(label)
+        if self.extra_widget:
+            packing_vbox._widget.pack_start(self.extra_widget._widget)
+        return packing_vbox
+
+    def add_button(self, text):
+        from lvc.widgets import dialogs
+        _stock = {
+            dialogs.BUTTON_OK.text: gtk.STOCK_OK,
+            dialogs.BUTTON_CANCEL.text: gtk.STOCK_CANCEL,
+            dialogs.BUTTON_YES.text: gtk.STOCK_YES,
+            dialogs.BUTTON_NO.text: gtk.STOCK_NO,
+            dialogs.BUTTON_QUIT.text: gtk.STOCK_QUIT,
+            dialogs.BUTTON_REMOVE.text: gtk.STOCK_REMOVE,
+            dialogs.BUTTON_DELETE.text: gtk.STOCK_DELETE,
+            }
+        if text in _stock:
+            # store both the text and the stock ID
+            text = _stock[text], text
+        self.buttons_to_add.append(text)
+
+    def pack_buttons(self):
+        # There's a couple tricky things here:
+        # 1) We need to add them in the reversed order we got them, since GTK
+        # lays them out left-to-right
+        #
+        # 2) We can't use 0 as a response-id.  GTK only reserves positive
+        # response_ids for the user.
+        response_id = len(self.buttons_to_add)
+        for text in reversed(self.buttons_to_add):
+            label = None
+            if isinstance(text, tuple): # stock ID, text
+                text, label = text
+            button = self._window.add_button(text, response_id)
+            if label is not None:
+                button.set_label(label)
+            response_id -= 1
+        self.buttons_to_add = []
+        self._window.set_default_response(1)
+
+    def _run(self):
+        self.pack_buttons()
+        packing_vbox = self.build_content()
+        self._window.vbox.pack_start(packing_vbox._widget, True, True)
+        self._window.show_all()
+        response = self._window.run()
+        self._window.hide()
+        if response == gtk.RESPONSE_DELETE_EVENT:
+            return -1
+        else:
+            return response - 1 # response IDs started at 1
+
+    def set_extra_widget(self, widget):
+        self.extra_widget = widget
+
+    def get_extra_widget(self):
+        return self.extra_widget
+
+class FileDialogBase(DialogBase):
+    def _run(self):
+        ret = self._window.run()
+        self._window.hide()
+        if ret == gtk.RESPONSE_OK:
+            self._files = self._window.get_filenames()
+            return 0
+
+class FileOpenDialog(FileDialogBase):
+    def __init__(self, title):
+        FileDialogBase.__init__(self)
+        self._files = None
+        fcd = gtk.FileChooserDialog(title,
+                                    action=gtk.FILE_CHOOSER_ACTION_OPEN,
+                                    buttons=(gtk.STOCK_CANCEL,
+                                             gtk.RESPONSE_CANCEL,
+                                             gtk.STOCK_OPEN,
+                                             gtk.RESPONSE_OK))
+
+        self.set_window(fcd)
+
+    def set_filename(self, text):
+        self._window.set_filename(text)
+
+    def set_select_multiple(self, value):
+        self._window.set_select_multiple(value)
+
+    def add_filters(self, filters):
+        for name, ext_list in filters:
+            f = gtk.FileFilter()
+            f.set_name(name)
+            for mem in ext_list:
+                f.add_pattern('*.%s' % mem)
+            self._window.add_filter(f)
+
+        f = gtk.FileFilter()
+        f.set_name(_('All files'))
+        f.add_pattern('*')
+        self._window.add_filter(f)
+
+    def get_filenames(self):
+        return [unicode(f) for f in self._files]
+
+    def get_filename(self):
+        if self._files is None:
+            # clicked Cancel
+            return None
+        else:
+            return unicode(self._files[0])
+
+    # provide a common interface for file chooser dialogs
+    get_path = get_filename
+    def set_path(self, path):
+        # set_filename puts the whole path in the filename field
+        self._window.set_current_folder(os.path.dirname(path))
+        self._window.set_current_name(os.path.basename(path))
+
+class FileSaveDialog(FileDialogBase):
+    def __init__(self, title):
+        FileDialogBase.__init__(self)
+        self._files = None
+        fcd = gtk.FileChooserDialog(title,
+                                    action=gtk.FILE_CHOOSER_ACTION_SAVE,
+                                    buttons=(gtk.STOCK_CANCEL,
+                                             gtk.RESPONSE_CANCEL,
+                                             gtk.STOCK_SAVE,
+                                             gtk.RESPONSE_OK))
+        self.set_window(fcd)
+
+    def set_filename(self, text):
+        self._window.set_current_name(text)
+
+    def get_filename(self):
+        if self._files is None:
+            # clicked Cancel
+            return None
+        else:
+            return unicode(self._files[0])
+
+    # provide a common interface for file chooser dialogs
+    get_path = get_filename
+    def set_path(self, path):
+        # set_filename puts the whole path in the filename field
+        self._window.set_current_folder(os.path.dirname(path))
+        self._window.set_current_name(os.path.basename(path))
+
+class DirectorySelectDialog(FileDialogBase):
+    def __init__(self, title):
+        FileDialogBase.__init__(self)
+        self._files = None
+        choose_str = 'Choose'
+        fcd = gtk.FileChooserDialog(
+            title,
+            action=gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
+            buttons=(gtk.STOCK_CANCEL,
+                     gtk.RESPONSE_CANCEL,
+                     choose_str, gtk.RESPONSE_OK))
+        self.set_window(fcd)
+
+    def set_directory(self, text):
+        self._window.set_filename(text)
+
+    def get_directory(self):
+        if self._files is None:
+            # clicked Cancel
+            return None
+        else:
+            return unicode(self._files[0])
+
+    # provide a common interface for file chooser dialogs
+    get_path = get_directory
+    set_path = set_directory
+
+class AboutDialog(Dialog):
+    def __init__(self):
+        Dialog.__init__(self, "Libre Video Converter")
+#            _("About %(appname)s",
+#              {'appname': app.config.get(prefs.SHORT_APP_NAME)}))
+#        self.add_button(_("Close"))
+        self.add_button("Close")
+        self._window.set_has_separator(False)
+
+    def build_content(self):
+        packing_vbox = layout.VBox(spacing=20)
+        #icon_pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(
+        #        resources.share_path('icons/hicolor/128x128/apps/miro.png'),
+        #        48, 48)
+        #packing_vbox._widget.pack_start(gtk.image_new_from_pixbuf(icon_pixbuf))
+        #if app.config.get(prefs.APP_REVISION_NUM):
+        #    version = "%s (%s)" % (
+        #        app.config.get(prefs.APP_VERSION),
+        #        app.config.get(prefs.APP_REVISION_NUM))
+        #else:
+        #    version = "%s" % app.config.get(prefs.APP_VERSION)
+        version = '1.0.1'
+        #name_label = gtk.Label(
+        #    '<span size="xx-large" weight="bold">%s %s</span>' % (
+        #        app.config.get(prefs.SHORT_APP_NAME), version))
+        name_label = gtk.Label(
+            '<span size="xx-large" weight="bold">%s %s</span>' % (
+                'Libre Video Converter', version))
+        name_label.set_use_markup(True)
+        packing_vbox._widget.pack_start(name_label)
+        copyright_text = 'Copyright (c) Jesus Eduardo (Heckyel) | 2017'
+        copyright_label = gtk.Label('<small>%s</small>' % copyright_text)
+        copyright_label.set_use_markup(True)
+        copyright_label.set_justify(gtk.JUSTIFY_CENTER)
+        packing_vbox._widget.pack_start(copyright_label)
+
+        # FIXME - make the project url clickable
+        #packing_vbox._widget.pack_start(
+        #    gtk.Label(app.config.get(prefs.PROJECT_URL)))
+
+        #contributor_label = gtk.Label(
+        #    _("Thank you to all the people who contributed to %(appname)s "
+        #      "%(version)s:",
+        #      {"appname": app.config.get(prefs.SHORT_APP_NAME),
+        #       "version": app.config.get(prefs.APP_VERSION)}))
+        #contributor_label.set_justify(gtk.JUSTIFY_CENTER)
+        #packing_vbox._widget.pack_start(contributor_label)
+
+        # get contributors, remove newlines and wrap it
+        #contributors = open(resources.path('CREDITS'), 'r').readlines()
+        #contributors = [c[2:].strip()
+        #                for c in contributors if c.startswith("* ")]
+        #contributors = ", ".join(contributors)
+
+        # show contributors
+        #contrib_buffer = gtk.TextBuffer()
+        #contrib_buffer.set_text(contributors)
+
+        #contrib_view = gtk.TextView(contrib_buffer)
+        #contrib_view.set_editable(False)
+        #contrib_view.set_cursor_visible(False)
+        #contrib_view.set_wrap_mode(gtk.WRAP_WORD)
+        #contrib_window = gtk.ScrolledWindow()
+        #contrib_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
+        #contrib_window.add(contrib_view)
+        #contrib_window.set_size_request(-1, 100)
+        #packing_vbox._widget.pack_start(contrib_window)
+
+        # FIXME - make the project url clickable
+        #donate_label = gtk.Label(
+        #    _("To help fund continued %(appname)s development, visit the "
+        #      "donation page at:",
+        #      {"appname": app.config.get(prefs.SHORT_APP_NAME)}))
+        #donate_label.set_justify(gtk.JUSTIFY_CENTER)
+        #packing_vbox._widget.pack_start(donate_label)
+
+        #packing_vbox._widget.pack_start(
+        #    gtk.Label(app.config.get(prefs.DONATE_URL)))
+        return packing_vbox
+
+    def on_contrib_link_event(self, texttag, widget, event, iter_):
+        if event.type == gtk.gdk.BUTTON_PRESS:
+            resources.open_url('https://notabug.org/heckyel/librevideoconverter')
+
+type_map = {
+    0: gtk.MESSAGE_WARNING,
+    1: gtk.MESSAGE_INFO,
+    2: gtk.MESSAGE_ERROR
+}
+
+class AlertDialog(DialogBase):
+    def __init__(self, title, description, alert_type):
+        DialogBase.__init__(self)
+        message_type = type_map.get(alert_type, gtk.MESSAGE_INFO)
+        self.set_window(gtk.MessageDialog(type=message_type,
+                                          message_format=description))
+        self._window.set_title(title)
+        self.description = description
+
+    def add_button(self, text):
+        self._window.add_button(_stock.get(text, text), 1)
+        self._window.set_default_response(1)
+
+    def _run(self):
+        self._window.set_modal(False)
+        self._window.show_all()
+        response = self._window.run()
+        self._window.hide()
+        if response == gtk.RESPONSE_DELETE_EVENT:
+            return -1
+        else:
+            # response IDs start at 1
+            return response - 1
diff --git a/lvc/widgets/gtk/wrappermap.py b/lvc/widgets/gtk/wrappermap.py
new file mode 100644
index 0000000..c2b2aad
--- /dev/null
+++ b/lvc/widgets/gtk/wrappermap.py
@@ -0,0 +1,50 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".wrappermap -- Map GTK Widgets to the Libre Widget
+that wraps them.
+"""
+
+import weakref
+
+# Maps gtk windows -> wrapper objects.  We use a weak references to prevent
+# circular references between the GTK widget and it's wrapper.  (Keeping a
+# reference to the GTK widget is fine, since if the wrapper is alive, the GTK
+# widget should be).
+widget_mapping = weakref.WeakValueDictionary()
+
+def wrapper(gtk_widget):
+    """Find the wrapper widget for a GTK widget."""
+    try:
+        return widget_mapping[gtk_widget]
+    except KeyError:
+        raise KeyError("Widget wrapper no longer exists")
+
+def add(gtk_widget, wrapper):
+    widget_mapping[gtk_widget] = wrapper
diff --git a/lvc/widgets/keyboard.py b/lvc/widgets/keyboard.py
new file mode 100644
index 0000000..6700de2
--- /dev/null
+++ b/lvc/widgets/keyboard.py
@@ -0,0 +1,69 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""Define keyboard input in a platform-independant way."""
+
+(CTRL, ALT, SHIFT, CMD, MOD, RIGHT_ARROW, LEFT_ARROW, UP_ARROW,
+ DOWN_ARROW, SPACE, ENTER, DELETE, BKSPACE, ESCAPE,
+ F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12) = range(26)
+
+class Shortcut:
+    """Defines a shortcut key combination used to trigger this
+    menu item.
+
+    The first argument is the shortcut key.  Other arguments are
+    modifiers.
+
+    Examples:
+
+    >>> Shortcut("x", MOD)
+    >>> Shortcut(BKSPACE, MOD)
+
+    This is wrong:
+
+    >>> Shortcut(MOD, "x")
+    """
+    def __init__(self, shortcut, *modifiers):
+        self.shortcut = shortcut
+        self.modifiers = modifiers
+
+    def _get_key_symbol(self, value):
+        """Translate key values to their symbolic names."""
+        if isinstance(self.shortcut, int):
+            shortcut_string = '<Unknown>'
+            for name, value in globals().iteritems():
+                if value == self.shortcut:
+                    return name
+        return repr(value)
+
+    def __str__(self):
+        shortcut_string = self._get_key_symbol(self.shortcut)
+        mod_string = repr(set(self._get_key_symbol(k) for k in
+                              self.modifiers))
+        return "Shortcut(%s, %s)" % (shortcut_string, mod_string)
diff --git a/lvc/widgets/menus.py b/lvc/widgets/menus.py
new file mode 100644
index 0000000..4e23b46
--- /dev/null
+++ b/lvc/widgets/menus.py
@@ -0,0 +1,268 @@
+# menus.py
+#
+# Most of these are taken from libs/frontends/widgets/menus.py in the miro
+# project.
+#
+# TODO: merge common bits!
+
+import collections
+
+from lvc import signals
+from lvc.widgets import widgetutil
+from lvc.widgets import widgetset
+from lvc.widgets import app
+
+from lvc.widgets.keyboard import (Shortcut, CTRL, ALT, SHIFT, CMD,
+     MOD, RIGHT_ARROW, LEFT_ARROW, UP_ARROW, DOWN_ARROW, SPACE, ENTER, DELETE,
+     BKSPACE, ESCAPE, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
+
+# XXX hack:
+
+def _(text, *params):
+    if params:
+       return text % params[0]
+    return text
+
+class MenuItem(widgetset.MenuItem):
+    """Portable MenuItem class.
+
+    This adds group handling to the platform menu items.
+    """
+    # group_map is used for the legacy menu updater code
+    group_map = collections.defaultdict(set)
+
+    def __init__(self, label, name, shortcut=None, groups=None,
+                 **state_labels):
+        widgetset.MenuItem.__init__(self, label, name, shortcut)
+        # state_labels is used for the legacy menu updater code
+        self.state_labels = state_labels
+        if groups:
+            if len(groups) > 1:
+                raise ValueError("only support one group")
+            MenuItem.group_map[groups[0]].add(self)
+
+class MenuItemFetcher(object):
+    """Get MenuItems by their name quickly.  """
+
+    def __init__(self):
+        self._cache = {}
+
+    def __getitem__(self, name):
+        if name in self._cache:
+            return self._cache[name]
+        else:
+            menu_item = app.widgetapp.menubar.find(name)
+            self._cache[name] = menu_item
+            return menu_item
+
+def get_app_menu():
+    """Returns the default menu structure."""
+
+    app_name = "Libre Video Converter"    # XXX HACK
+
+    file_menu = widgetset.Menu(_("_File"), "FileMenu", [
+                    MenuItem(_("_Open"), "Open", Shortcut("o", MOD),
+                             groups=["NonPlaying"]),
+                    MenuItem(_("_Quit"), "Quit", Shortcut("q", MOD)),
+                    ])
+    help_menu = widgetset.Menu(_("_Help"), "HelpMenu", [
+                    MenuItem(_("About %(name)s",
+                               {'name': app_name}),
+                             "About")
+                    ])
+
+    all_menus = [file_menu, help_menu]
+    return all_menus
+
+action_handlers = {}
+group_action_handlers = {}
+
+def on_menubar_activate(menubar, action_name):
+    callback = lookup_handler(action_name)
+    if callback is not None:
+        callback()
+
+def lookup_handler(action_name):
+    """For a given action name, get a callback to handle it.  Return
+    None if no callback is found.
+    """
+
+    retval = _lookup_group_handler(action_name)
+    if retval is None:
+        retval = action_handlers.get(action_name)
+    return retval
+
+def _lookup_group_handler(action_name):
+    try:
+        group_name, callback_arg = action_name.split('-', 1)
+    except ValueError:
+        return None # split return tuple of length 1
+    try:
+        group_handler = group_action_handlers[group_name]
+    except KeyError:
+        return None
+    else:
+        return lambda: group_handler(callback_arg)
+
+def action_handler(name):
+    """Decorator for functions that handle menu actions."""
+    def decorator(func):
+        action_handlers[name] = func
+        return func
+    return decorator
+
+def group_action_handler(action_prefix):
+    def decorator(func):
+        group_action_handlers[action_prefix] = func
+        return func
+    return decorator
+
+# File menu
+@action_handler("Open")
+def on_open():
+    app.widgetapp.choose_file()
+
+@action_handler("Quit")
+def on_quit():
+    app.widgetapp.quit()
+
+# Help menu
+@action_handler("About")
+def on_about():
+    app.widgetapp.about()
+
+class MenuManager(signals.SignalEmitter):
+    """Updates the menu based on the current selection.
+
+    This includes enabling/disabling menu items, changing menu text
+    for plural selection and enabling/disabling the play button.  The
+    play button is obviously not a menu item, but it's pretty closely
+    related
+
+    Whenever code makes a change that could possibly affect which menu
+    items should be enabled/disabled, it should call the
+    update_menus() method.
+
+    Signals:
+    - menus-updated(reasons): Emitted whenever update_menus() is called
+    """
+    def __init__(self):
+        signals.SignalEmitter.__init__(self, 'menus-updated')
+        self.menu_item_fetcher = MenuItemFetcher()
+        #self.subtitle_encoding_updater = SubtitleEncodingMenuUpdater()
+        self.subtitle_encoding_updater = None
+
+    def setup_menubar(self, menubar):
+        """Setup the main miro menubar.
+        """
+        menubar.add_initial_menus(get_app_menu())
+        menubar.connect("activate", on_menubar_activate)
+        self.menu_updaters = []
+
+    def _set_play_pause(self):
+        if ((not app.playback_manager.is_playing
+             or app.playback_manager.is_paused)):
+            label = _('Play')
+        else:
+            label = _('Pause')
+        self.menu_item_fetcher['PlayPauseItem'].set_label(label)
+
+    def add_subtitle_encoding_menu(self, category_label, *encodings):
+        """Set up a subtitles encoding menu.
+
+        This method should be called for each category of subtitle encodings
+        (East Asian, Western European, Unicode, etc).  Pass it the list of
+        encodings for that category.
+
+        :param category_label: human-readable name for the category
+        :param encodings: list of (label, encoding) tuples.  label is a
+            human-readable name, and encoding is a value that we can pass to
+            VideoDisplay.select_subtitle_encoding()
+        """
+        self.subtitle_encoding_updater.add_menu(category_label, encodings)
+
+    def select_subtitle_encoding(self, encoding):
+        if not self.subtitle_encoding_updater.has_encodings():
+            # OSX never sets up the subtitle encoding menu
+            return
+        menu_item_name = self.subtitle_encoding_updater.action_name(encoding)
+        try:
+            self.menu_item_fetcher[menu_item_name].set_state(True)
+        except KeyError:
+            logging.warn("Error enabling subtitle encoding menu item: %s",
+                         menu_item_name)
+
+    def update_menus(self, *reasons):
+        """Call this when a change is made that could change the menus
+
+        Use reasons to describe why the menus could change.  Some MenuUpdater
+        objects will do some optimizations based on that
+        """
+        reasons = set(reasons)
+        self._set_play_pause()
+        for menu_updater in self.menu_updaters:
+            menu_updater.update(reasons)
+        self.emit('menus-updated', reasons)
+
+class MenuUpdater(object):
+    """Base class for objects that dynamically update menus."""
+    def __init__(self, menu_name):
+        self.menu_name = menu_name
+        self.first_update = False
+
+    # we lazily access our menu item, since we are created before the menubar
+    # is fully setup.
+    def get_menu(self):
+        try:
+            return self._menu
+        except AttributeError:
+            self._menu = app.widgetapp.menubar.find(self.menu_name)
+            return self._menu
+    menu = property(get_menu)
+
+    def update(self, reasons):
+        if not self.first_update and not self.should_process_update(reasons):
+            return
+        self.first_update = False
+        self.start_update()
+        if not self.should_show_menu():
+            self.menu.hide()
+            return
+
+        self.menu.show()
+        if self.should_rebuild_menu():
+            self.clear_menu()
+            self.populate_menu()
+        self.update_items()
+
+    def should_process_update(self, reasons):
+        """Test if we should ignore the update call.
+
+        :param reasons: the reasons passed in to MenuManager.update_menus()
+        """
+        return True
+
+    def clear_menu(self):
+        """Remove items from our menu before rebuilding it."""
+        for child in self.menu.get_children():
+            self.menu.remove(child)
+
+    def start_update(self):
+        """Called at the very start of the update method.  """
+        pass
+
+    def should_show_menu(self):
+        """Should we display the menu?  """
+        return True
+
+    def should_rebuild_menu(self):
+        """Should we rebuild the menu structure?"""
+        return False
+
+    def populate_menu(self):
+        """Add MenuItems to our menu."""
+        pass
+
+    def update_items(self):
+        """Update our menu items."""
+        pass
diff --git a/lvc/widgets/osx/Resources-Widgets/MainMenu.nib/designable.nib b/lvc/widgets/osx/Resources-Widgets/MainMenu.nib/designable.nib
new file mode 100644
index 0000000..b7fefd6
--- /dev/null
+++ b/lvc/widgets/osx/Resources-Widgets/MainMenu.nib/designable.nib
@@ -0,0 +1,145 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<archive type="com.apple.InterfaceBuilder3.Cocoa.XIB" version="8.00">
+	<data>
+		<int key="IBDocument.SystemTarget">1060</int>
+		<string key="IBDocument.SystemVersion">12A269</string>
+		<string key="IBDocument.InterfaceBuilderVersion">2549</string>
+		<string key="IBDocument.AppKitVersion">1187</string>
+		<string key="IBDocument.HIToolboxVersion">624.00</string>
+		<object class="NSMutableDictionary" key="IBDocument.PluginVersions">
+			<string key="NS.key.0">com.apple.InterfaceBuilder.CocoaPlugin</string>
+			<string key="NS.object.0">2549</string>
+		</object>
+		<array key="IBDocument.IntegratedClassDependencies">
+			<string>NSCustomObject</string>
+			<string>NSMenu</string>
+			<string>NSMenuItem</string>
+		</array>
+		<array key="IBDocument.PluginDependencies">
+			<string>com.apple.InterfaceBuilder.CocoaPlugin</string>
+		</array>
+		<object class="NSMutableDictionary" key="IBDocument.Metadata">
+			<string key="NS.key.0">PluginDependencyRecalculationVersion</string>
+			<integer value="1" key="NS.object.0"/>
+		</object>
+		<array class="NSMutableArray" key="IBDocument.RootObjects" id="864178278">
+			<object class="NSCustomObject" id="422340081">
+				<object class="NSMutableString" key="NSClassName">
+					<characters key="NS.bytes">NSApplication</characters>
+				</object>
+			</object>
+			<object class="NSCustomObject" id="99063961">
+				<string key="NSClassName">FirstResponder</string>
+			</object>
+			<object class="NSCustomObject" id="399126242">
+				<string key="NSClassName">NSApplication</string>
+			</object>
+			<object class="NSMenu" id="603720448">
+				<string key="NSTitle">MainMenu</string>
+				<array class="NSMutableArray" key="NSMenuItems">
+					<object class="NSMenuItem" id="726726549">
+						<reference key="NSMenu" ref="603720448"/>
+						<string key="NSTitle">Libre Video Converter</string>
+						<string key="NSKeyEquiv"/>
+						<int key="NSKeyEquivModMask">1048576</int>
+						<int key="NSMnemonicLoc">2147483647</int>
+						<object class="NSCustomResource" key="NSOnImage">
+							<string key="NSClassName">NSImage</string>
+							<string key="NSResourceName">NSMenuCheckmark</string>
+						</object>
+						<object class="NSCustomResource" key="NSMixedImage">
+							<string key="NSClassName">NSImage</string>
+							<string key="NSResourceName">NSMenuMixedState</string>
+						</object>
+						<string key="NSAction">submenuAction:</string>
+						<object class="NSMenu" key="NSSubmenu" id="530441688">
+							<string key="NSTitle">Libre Video Converter</string>
+							<array class="NSMutableArray" key="NSMenuItems"/>
+							<string key="NSName">_NSAppleMenu</string>
+						</object>
+					</object>
+				</array>
+				<string key="NSName">_NSMainMenu</string>
+			</object>
+		</array>
+		<object class="IBObjectContainer" key="IBDocument.Objects">
+			<array class="NSMutableArray" key="connectionRecords"/>
+			<object class="IBMutableOrderedSet" key="objectRecords">
+				<array key="orderedObjects">
+					<object class="IBObjectRecord">
+						<int key="objectID">0</int>
+						<array key="object" id="0"/>
+						<reference key="children" ref="864178278"/>
+						<nil key="parent"/>
+					</object>
+					<object class="IBObjectRecord">
+						<int key="objectID">-2</int>
+						<reference key="object" ref="422340081"/>
+						<reference key="parent" ref="0"/>
+						<string key="objectName">File's Owner</string>
+					</object>
+					<object class="IBObjectRecord">
+						<int key="objectID">-1</int>
+						<reference key="object" ref="99063961"/>
+						<reference key="parent" ref="0"/>
+						<string key="objectName">First Responder</string>
+					</object>
+					<object class="IBObjectRecord">
+						<int key="objectID">29</int>
+						<reference key="object" ref="603720448"/>
+						<array class="NSMutableArray" key="children">
+							<reference ref="726726549"/>
+						</array>
+						<reference key="parent" ref="0"/>
+						<string key="objectName">MainMenu</string>
+					</object>
+					<object class="IBObjectRecord">
+						<int key="objectID">56</int>
+						<reference key="object" ref="726726549"/>
+						<array class="NSMutableArray" key="children">
+							<reference ref="530441688"/>
+						</array>
+						<reference key="parent" ref="603720448"/>
+					</object>
+					<object class="IBObjectRecord">
+						<int key="objectID">57</int>
+						<reference key="object" ref="530441688"/>
+						<reference key="parent" ref="726726549"/>
+					</object>
+					<object class="IBObjectRecord">
+						<int key="objectID">-3</int>
+						<reference key="object" ref="399126242"/>
+						<reference key="parent" ref="0"/>
+						<string key="objectName">Application</string>
+					</object>
+				</array>
+			</object>
+			<dictionary class="NSMutableDictionary" key="flattenedProperties">
+				<string key="-1.IBPluginDependency">com.apple.InterfaceBuilder.CocoaPlugin</string>
+				<string key="-2.IBPluginDependency">com.apple.InterfaceBuilder.CocoaPlugin</string>
+				<string key="-3.IBPluginDependency">com.apple.InterfaceBuilder.CocoaPlugin</string>
+				<string key="29.IBPluginDependency">com.apple.InterfaceBuilder.CocoaPlugin</string>
+				<string key="56.IBPluginDependency">com.apple.InterfaceBuilder.CocoaPlugin</string>
+				<string key="57.IBPluginDependency">com.apple.InterfaceBuilder.CocoaPlugin</string>
+			</dictionary>
+			<dictionary class="NSMutableDictionary" key="unlocalizedProperties"/>
+			<nil key="activeLocalization"/>
+			<dictionary class="NSMutableDictionary" key="localizations"/>
+			<nil key="sourceID"/>
+			<int key="maxID">248</int>
+		</object>
+		<object class="IBClassDescriber" key="IBDocument.Classes"/>
+		<int key="IBDocument.localizationMode">0</int>
+		<string key="IBDocument.TargetRuntimeIdentifier">IBCocoaFramework</string>
+		<object class="NSMutableDictionary" key="IBDocument.PluginDeclaredDependencies">
+			<string key="NS.key.0">com.apple.InterfaceBuilder.CocoaPlugin.macosx</string>
+			<real value="1060" key="NS.object.0"/>
+		</object>
+		<bool key="IBDocument.PluginDeclaredDependenciesTrackSystemTargetVersion">YES</bool>
+		<int key="IBDocument.defaultPropertyAccessControl">3</int>
+		<dictionary class="NSMutableDictionary" key="IBDocument.LastKnownImageSizes">
+			<string key="NSMenuCheckmark">{11, 11}</string>
+			<string key="NSMenuMixedState">{10, 3}</string>
+		</dictionary>
+	</data>
+</archive>
diff --git a/lvc/widgets/osx/Resources-Widgets/MainMenu.nib/keyedobjects.nib b/lvc/widgets/osx/Resources-Widgets/MainMenu.nib/keyedobjects.nib
new file mode 100644
index 0000000..963b444
--- /dev/null
+++ b/lvc/widgets/osx/Resources-Widgets/MainMenu.nib/keyedobjects.nib
diff --git a/lvc/widgets/osx/__init__.py b/lvc/widgets/osx/__init__.py
new file mode 100644
index 0000000..86653eb
--- /dev/null
+++ b/lvc/widgets/osx/__init__.py
@@ -0,0 +1,74 @@
+import sys
+
+from objc import *
+from Foundation import *
+from AppKit import *
+
+from PyObjCTools import AppHelper
+
+size_request_manager = None
+
+class AppController(NSObject):
+    def applicationDidFinishLaunching_(self, notification):
+        from lvc.widgets.osx.osxmenus import MenuBar
+        self.portableApp.menubar = MenuBar()
+        self.portableApp.startup()
+        self.portableApp.run()
+
+    def setPortableApp_(self, portableApp):
+        self.portableApp = portableApp
+
+    def handleMenuActivate_(self, menu_item):
+        from lvc.widgets.osx import osxmenus
+        osxmenus.handle_menu_activate(menu_item)
+
+def initialize(app):
+    nsapp = NSApplication.sharedApplication()
+    delegate = AppController.alloc().init()
+    delegate.setPortableApp_(app)
+    nsapp.setDelegate_(delegate)
+
+    global size_request_manager
+    from lvc.widgets.osx.widgetupdates import SizeRequestManager
+    size_request_manager = SizeRequestManager()
+
+    NSApplicationMain(sys.argv)
+
+def attach_menubar():
+    pass
+
+def mainloop_start():
+    pass
+
+def mainloop_stop():
+    NSApplication.sharedApplication().terminate_(nil)
+
+def idle_add(callback, periodic=None):
+    def wrapper():
+        callback()
+        if periodic is not None:
+            AppHelper.callLater(periodic, wrapper)
+    if periodic is not None and periodic < 0:
+        raise ValueError('periodic cannot be negative')
+    # XXX: we have a lousy thread API that doesn't allocate pools for us...
+    pool = NSAutoreleasePool.alloc().init()
+    if periodic is not None:
+        AppHelper.callLater(periodic, wrapper)
+    else:
+        AppHelper.callAfter(wrapper)
+    del pool
+
+def idle_remove(id_):
+    pass
+
+def reveal_file(filename):
+    # XXX: dumb lousy type conversions ...
+    path = NSURL.fileURLWithPath_(filename.decode('utf-8')).path()
+    NSWorkspace.sharedWorkspace().selectFile_inFileViewerRootedAtPath_(
+        path, nil)
+
+def get_conversion_directory():
+    url, error = NSFileManager.defaultManager().URLForDirectory_inDomain_appropriateForURL_create_error_(NSMoviesDirectory, NSUserDomainMask, nil, YES, None)
+    if error:
+        return None
+    return url.path().encode('utf-8')
diff --git a/lvc/widgets/osx/base.py b/lvc/widgets/osx/base.py
new file mode 100644
index 0000000..30536aa
--- /dev/null
+++ b/lvc/widgets/osx/base.py
@@ -0,0 +1,367 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".base.py -- Widget base classes."""
+
+from AppKit import *
+from Foundation import *
+from objc import YES, NO, nil
+
+from lvc import signals
+import wrappermap
+from .viewport import Viewport, BorrowedViewport
+
+class Widget(signals.SignalEmitter):
+    """Base class for Cocoa widgets.
+
+    attributes:
+
+    CREATES_VIEW -- Does the widget create a view for itself?  If this is True
+    the widget must have an attribute named view, which is the view that the
+    widget uses.
+
+    placement -- What portion of view the widget occupies.
+    """
+
+    CREATES_VIEW = True
+
+    def __init__(self):
+        signals.SignalEmitter.__init__(self, 'size-request-changed',
+                'size-allocated', 'key-press', 'focus-out')
+        self.create_signal('place-in-scroller')
+        self.viewport = None
+        self.parent_is_scroller = False
+        self.manual_size_request = None
+        self.cached_size_request = None
+        self._disabled = False
+
+    def set_can_focus(self, allow):
+        assert isinstance(self.view, NSControl)
+        self.view.setRefusesFirstResponder_(not allow)
+
+    def set_size_request(self, width, height):
+        self.manual_size_request = (width, height)
+        self.invalidate_size_request()
+
+    def clear_size_request_cache(self):
+        from lvc.widgets.osx import size_request_manager
+        if size_request_manager is not None:
+            while size_request_manager.widgets_to_request:
+                size_request_manager._run_requests()
+
+    def get_size_request(self):
+        if self.manual_size_request:
+            width, height = self.manual_size_request
+            if width == -1:
+                width = self.get_natural_size_request()[0]
+            if height == -1:
+                height = self.get_natural_size_request()[1]
+            return width, height
+        return self.get_natural_size_request()
+
+    def get_natural_size_request(self):
+        if self.cached_size_request:
+            return self.cached_size_request
+        else:
+            self.cached_size_request = self.calc_size_request()
+            return self.cached_size_request
+
+    def invalidate_size_request(self):
+        from lvc.widgets.osx import size_request_manager
+        if size_request_manager is not None:
+            size_request_manager.add_widget(self)
+
+    def do_invalidate_size_request(self):
+        """Recalculate the size request for this widget."""
+        old_size_request = self.cached_size_request
+        self.cached_size_request = None
+        self.emit('size-request-changed', old_size_request)
+
+    def calc_size_request(self):
+        """Return the minimum size needed to display this widget.
+        Must be Implemented by subclasses.
+        """
+        raise NotImplementedError()
+
+    def _debug_size_request(self, nesting_level=0):
+        """Debug size request calculations.
+
+        This method recursively prints out the size request for each widget.
+        """
+        request = self.calc_size_request()
+        width = int(request[0])
+        height = int(request[1])
+        indent = '    ' * nesting_level
+        me = str(self.__class__).split('.')[-1]
+        print '%s%s: %sx%s' % (indent, me, width, height)
+
+    def place(self, rect, containing_view):
+        """Place this widget on a view.  """
+        if self.viewport is None:
+            if self.CREATES_VIEW:
+                self.viewport = Viewport(self.view, rect)
+                containing_view.addSubview_(self.view)
+                wrappermap.add(self.view, self)
+            else:
+                self.viewport = BorrowedViewport(containing_view, rect)
+            self.viewport_created()
+        else:
+            if not self.viewport.at_position(rect):
+                self.viewport.reposition(rect)
+                self.viewport_repositioned()
+        self.emit('size-allocated', rect.size.width, rect.size.height)
+
+    def remove_viewport(self):
+        if self.viewport is not None:
+            self.viewport.remove()
+            self.viewport = None
+            if self.CREATES_VIEW:
+                wrappermap.remove(self.view)
+
+    def viewport_created(self):
+        """Called after we first create a viewport.  Subclasses can override
+        this method if they want to handle this event.
+        """
+
+    def viewport_repositioned(self):
+        """Called when we reposition our viewport.  Subclasses can override
+        this method if they want to handle this event.
+        """
+
+    def viewport_scrolled(self):
+        """Called by the Scroller widget on it's child widget when it is
+        scrolled.
+        """
+
+    def get_width(self):
+        return int(self.viewport.get_width())
+    width = property(get_width)
+
+    def get_height(self):
+        return int(self.viewport.get_height())
+    height = property(get_height)
+
+    def get_window(self):
+        if not self.viewport.view:
+            return None
+        return wrappermap.wrapper(self.viewport.view.window())
+
+    def queue_redraw(self):
+        if self.viewport:
+            self.viewport.queue_redraw()
+
+    def redraw_now(self):
+        if self.viewport:
+            self.viewport.redraw_now()
+
+    def relative_position(self, other_widget):
+        """Get the position of another widget, relative to this widget."""
+        basePoint = self.viewport.view.convertPoint_fromView_(
+                other_widget.viewport.area().origin,
+                other_widget.viewport.view)
+        return (basePoint.x - self.viewport.area().origin.x,
+                basePoint.y - self.viewport.area().origin.y)
+
+    def make_color(self, (red, green, blue)):
+        return NSColor.colorWithDeviceRed_green_blue_alpha_(red, green, blue,
+                1.0)
+
+    def enable(self):
+        self._disabled = False
+
+    def disable(self):
+        self._disabled = True
+
+    def set_disabled(self, disabled):
+        if disabled:
+            self.disable()
+        else:
+            self.enable()
+
+    def get_disabled(self):
+        return self._disabled
+
+class Container(Widget):
+    """Widget that holds other widgets.  """
+
+    def __init__(self):
+        Widget.__init__(self)
+        self.callback_handles = {}
+
+    def on_child_size_request_changed(self, child, old_size):
+        self.invalidate_size_request()
+
+    def connect_child_signals(self, child):
+        handle = child.connect_weak('size-request-changed',
+                self.on_child_size_request_changed)
+        self.callback_handles[child] = handle
+
+    def disconnect_child_signals(self, child):
+        child.disconnect(self.callback_handles.pop(child))
+
+    def remove_viewport(self):
+        for child in self.children:
+            child.remove_viewport()
+        Widget.remove_viewport(self)
+
+    def child_added(self, child):
+        """Must be called by subclasses when a child is added to the
+        Container."""
+        self.connect_child_signals(child)
+        self.children_changed()
+
+    def child_removed(self, child):
+        """Must be called by subclasses when a child is removed from the
+        Container."""
+        self.disconnect_child_signals(child)
+        child.remove_viewport()
+        self.children_changed()
+
+    def child_changed(self, old_child, new_child):
+        """Must be called by subclasses when a child is replaced by a new
+        child in the Container.  To simplify things a bit for subclasses,
+        old_child can be None in which case this is the same as
+        child_added(new_child).
+        """
+        if old_child is not None:
+            self.disconnect_child_signals(old_child)
+            old_child.remove_viewport()
+        self.connect_child_signals(new_child)
+        self.children_changed()
+
+    def children_changed(self):
+        """Invoked when the set of children for this widget changes."""
+        self.do_invalidate_size_request()
+
+    def do_invalidate_size_request(self):
+        Widget.do_invalidate_size_request(self)
+        if self.viewport:
+            self.place_children()
+
+    def viewport_created(self):
+        self.place_children()
+
+    def viewport_repositioned(self):
+        self.place_children()
+
+    def viewport_scrolled(self):
+        for child in self.children:
+            child.viewport_scrolled()
+
+    def place_children(self):
+        """Layout our child widgets.  Must be implemented by subclasses."""
+        raise NotImplementedError()
+
+    def _debug_size_request(self, nesting_level=0):
+        for child in self.children:
+            child._debug_size_request(nesting_level+1)
+        Widget._debug_size_request(self, nesting_level)
+
+class Bin(Container):
+    """Container that only has one child widget."""
+
+    def __init__(self, child=None):
+        Container.__init__(self)
+        self.child = None
+        if child is not None:
+            self.add(child)
+
+    def get_children(self):
+        if self.child:
+            return [self.child]
+        else:
+            return []
+    children = property(get_children)
+
+    def add(self, child):
+        if self.child is not None:
+            raise ValueError("Already have a child: %s" % self.child)
+        self.child = child
+        self.child_added(self.child)
+
+    def remove(self):
+        if self.child is not None:
+            old_child = self.child
+            self.child = None
+            self.child_removed(old_child)
+
+    def set_child(self, new_child):
+        old_child = self.child
+        self.child = new_child
+        self.child_changed(old_child, new_child)
+
+    def enable(self):
+        Container.enable(self)
+        self.child.enable()
+
+    def disable(self):
+        Container.disable(self)
+        self.child.disable()
+
+class SimpleBin(Bin):
+    """Bin that whose child takes up it's entire space."""
+
+    def calc_size_request(self):
+        if self.child is None:
+            return (0, 0)
+        else:
+            return self.child.get_size_request()
+
+    def place_children(self):
+        if self.child:
+            self.child.place(self.viewport.area(), self.viewport.view)
+
+class FlippedView(NSView):
+    """Flipped NSView.  We use these internally to lessen the differences
+    between Cocoa and GTK.
+    """
+
+    def init(self):
+        self = super(FlippedView, self).init()
+        self.background = None
+        return self
+
+    def initWithFrame_(self, rect):
+        self = super(FlippedView, self).initWithFrame_(rect)
+        self.background = None
+        return self
+
+    def isFlipped(self):
+        return YES
+
+    def isOpaque(self):
+        return self.background is not None
+
+    def setBackgroundColor_(self, color):
+        self.background = color
+
+    def drawRect_(self, rect):
+        if self.background:
+            self.background.set()
+            NSBezierPath.fillRect_(rect)
diff --git a/lvc/widgets/osx/const.py b/lvc/widgets/osx/const.py
new file mode 100644
index 0000000..ae0da40
--- /dev/null
+++ b/lvc/widgets/osx/const.py
@@ -0,0 +1,44 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+from AppKit import *
+
+"""const.py -- Constants"""
+
+DRAG_ACTION_NONE = NSDragOperationNone
+DRAG_ACTION_COPY = NSDragOperationCopy
+DRAG_ACTION_MOVE = NSDragOperationMove
+DRAG_ACTION_LINK = NSDragOperationLink
+DRAG_ACTION_ALL = (DRAG_ACTION_COPY | DRAG_ACTION_MOVE | DRAG_ACTION_LINK)
+
+ITEM_TITLE_FONT = "Helvetica"
+ITEM_DESC_FONT  = "Helvetica"
+ITEM_INFO_FONT  = "Lucida Grande"
+
+TOOLBAR_GRAY = (0.19, 0.19, 0.19)
diff --git a/lvc/widgets/osx/contextmenu.py b/lvc/widgets/osx/contextmenu.py
new file mode 100644
index 0000000..7a8fa55
--- /dev/null
+++ b/lvc/widgets/osx/contextmenu.py
@@ -0,0 +1,84 @@
+from AppKit import *
+from objc import nil
+
+from .base import Widget
+
+class ContextMenuHandler(NSObject):
+    def initWithCallback_widget_i_(self, callback, widget, i):
+        self = super(ContextMenuHandler, self).init()
+        self.callback = callback
+        self.widget = widget
+        self.i = i
+        return self
+
+    def handleMenuItem_(self, sender):
+        self.callback(self.widget, self.i)
+
+
+class MiroContextMenu(NSMenu):
+    # Works exactly like NSMenu, except it keeps a reference to the menu
+    # handler objects.
+    def init(self):
+        self = super(MiroContextMenu, self).init()
+        self.handlers = set()
+        return self
+
+    def addItem_(self, item):
+        if isinstance(item.target(), ContextMenuHandler):
+            self.handlers.add(item.target())
+        return NSMenu.addItem_(self, item)
+
+
+class ContextMenu(object):
+
+    def __init__(self, options):
+        super(ContextMenu, self).__init__()
+        self.menu = MiroContextMenu.alloc().init()
+        for i, item_info in enumerate(options):
+            if item_info is None:
+                nsitem = NSMenuItem.separatorItem()
+            else:
+                label, callback = item_info
+                nsitem = NSMenuItem.alloc().init()
+                font_size = NSFont.systemFontSize()
+                font = NSFont.fontWithName_size_("Lucida Sans Italic", font_size)
+                if font is None:
+                    font = NSFont.systemFontOfSize_(font_size)
+                    attributes = {NSFontAttributeName: font}
+                    attributed_label = NSAttributedString.alloc().initWithString_attributes_(label, attributes)
+                    nsitem.setAttributedTitle_(attributed_label)
+                else:
+                    nsitem.setTitle_(label)
+                if isinstance(callback, list):
+                    submenu = ContextMenu(callback)
+                    self.menu.setSubmenu_forItem_(submenu.menu, nsitem)
+                else:
+                    handler = ContextMenuHandler.alloc().initWithCallback_widget_i_(callback, self, i)
+                    nsitem.setTarget_(handler)
+                    nsitem.setAction_('handleMenuItem:')
+            self.menu.addItem_(nsitem)
+
+    def popup(self):
+        # support for non-window based popups thanks to
+        # http://stackoverflow.com/questions/9033534/how-can-i-pop-up-nsmenu-at-mouse-cursor-position
+        location = NSEvent.mouseLocation()
+        frame = NSMakeRect(location.x, location.y, 200, 200)
+        window = NSWindow.alloc().initWithContentRect_styleMask_backing_defer_(
+            frame,
+            NSBorderlessWindowMask,
+            NSBackingStoreBuffered,
+            NO)
+        window.setAlphaValue_(0)
+        window.makeKeyAndOrderFront_(NSApp)
+        location_in_window = window.convertScreenToBase_(location)
+        event = NSEvent.mouseEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_clickCount_pressure_(
+            NSLeftMouseDown,
+            location_in_window,
+            0,
+            0,
+            window.windowNumber(),
+            nil,
+            0,
+            0,
+            0)
+        NSMenu.popUpContextMenu_withEvent_forView_(self.menu, event, window.contentView())
diff --git a/lvc/widgets/osx/control.py b/lvc/widgets/osx/control.py
new file mode 100644
index 0000000..63419d5
--- /dev/null
+++ b/lvc/widgets/osx/control.py
@@ -0,0 +1,530 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".control - Controls."""
+
+from AppKit import *
+from Foundation import *
+from objc import YES, NO, nil
+
+from lvc.widgets import widgetconst
+import wrappermap
+from .base import Widget
+from .helpers import NotificationForwarder
+
+class SizedControl(Widget):
+    def set_size(self, size):
+        if size == widgetconst.SIZE_NORMAL:
+            self.view.cell().setControlSize_(NSRegularControlSize)
+            font = NSFont.systemFontOfSize_(NSFont.systemFontSize())
+            self.font_size = NSFont.systemFontSize()
+        elif size == widgetconst.SIZE_SMALL:
+            font = NSFont.systemFontOfSize_(NSFont.smallSystemFontSize())
+            self.view.cell().setControlSize_(NSSmallControlSize)
+            self.font_size = NSFont.smallSystemFontSize()
+        else:
+            self.view.cell().setControlSize_(NSRegularControlSize)
+            font = NSFont.systemFontOfSize_(NSFont.systemFontSize() * size)
+            self.font_size = NSFont.systemFontSize() * size
+        self.view.setFont_(font)
+
+class BaseTextEntry(SizedControl):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self, initial_text=None):
+        SizedControl.__init__(self)
+        self.view = self.make_view()
+        self.font = NSFont.systemFontOfSize_(NSFont.systemFontSize())
+        self.view.setFont_(self.font)
+        self.view.setEditable_(YES)
+        self.view.cell().setScrollable_(YES)
+        self.view.cell().setLineBreakMode_(NSLineBreakByClipping)
+        self.sizer_cell = self.view.cell().copy()
+        if initial_text:
+            self.view.setStringValue_(initial_text)
+            self.set_width(len(initial_text))
+        else:
+            self.set_width(10)
+
+        self.notifications = NotificationForwarder.create(self.view)
+
+        self.create_signal('activate')
+        self.create_signal('changed')
+        self.create_signal('validate')
+
+    def focus(self):
+        if self.view.window() is not None:
+            self.view.window().makeFirstResponder_(self.view)
+
+    def start_editing(self, initial_text):
+        self.set_text(initial_text)
+        self.focus()
+        # unselect the text and locate the cursor at the end of the entry
+        text_field = self.view.window().fieldEditor_forObject_(YES, self.view)
+        text_field.setSelectedRange_(NSMakeRange(len(self.get_text()), 0))
+
+    def viewport_created(self):
+        SizedControl.viewport_created(self)
+        self.notifications.connect(self.on_changed, 'NSControlTextDidChangeNotification')
+        self.notifications.connect(self.on_end_editing,
+                'NSControlTextDidEndEditingNotification')
+
+    def remove_viewport(self):
+        SizedControl.remove_viewport(self)
+        self.notifications.disconnect()
+
+    def baseline(self):
+        return -self.view.font().descender() + 2
+
+    def on_changed(self, notification):
+        self.emit('changed')
+
+    def on_end_editing(self, notification):
+        self.emit('focus-out')
+
+    def calc_size_request(self):
+        size = self.sizer_cell.cellSize()
+        return size.width, size.height
+
+    def set_text(self, text):
+        self.view.setStringValue_(text)
+        self.emit('changed')
+
+    def get_text(self):
+        return self.view.stringValue()
+
+    def set_width(self, chars):
+        self.sizer_cell.setStringValue_('X' * chars)
+        self.invalidate_size_request()
+
+    def set_activates_default(self, setting):
+        pass
+
+    def enable(self):
+        SizedControl.enable(self)
+        self.view.setEnabled_(True)
+
+    def disable(self):
+        SizedControl.disable(self)
+        self.view.setEnabled_(False)
+
+class MiroTextField(NSTextField):
+    def textDidEndEditing_(self, notification):
+        wrappermap.wrapper(self).emit('activate')
+        return NSTextField.textDidEndEditing_(self, notification)
+
+class TextEntry(BaseTextEntry):
+    def make_view(self):
+        return MiroTextField.alloc().init()
+
+class NumberEntry(BaseTextEntry):
+    def make_view(self):
+        return MiroTextField.alloc().init()
+
+    def set_max_length(self, length):
+        # TODO
+        pass
+
+    def _filter_value(self):
+        """Discard any non-numeric characters"""
+        digits = ''.join(x for x in self.view.stringValue() if x.isdigit())
+        self.view.setStringValue_(digits)
+
+    def on_changed(self, notification):
+        # overriding on_changed rather than connecting to it ensures that we
+        # filter the value before anything else connected to the signal sees it
+        self._filter_value()
+        BaseTextEntry.on_changed(self, notification)
+
+    def get_text(self):
+        # handles get_text between when text is entered and when on_changed
+        # filters it, in case that's possible
+        self._filter_value()
+        return BaseTextEntry.get_text(self)
+
+class MiroSecureTextField(NSSecureTextField):
+    def textDidEndEditing_(self, notification):
+        wrappermap.wrapper(self).emit('activate')
+        return NSSecureTextField.textDidEndEditing_(self, notification)
+
+class SecureTextEntry(BaseTextEntry):
+    def make_view(self):
+        return MiroSecureTextField.alloc().init()
+
+class MultilineTextEntry(Widget):
+    def __init__(self, initial_text=None):
+        Widget.__init__(self)
+        if initial_text is None:
+            initial_text = ""
+        self.view = NSTextView.alloc().initWithFrame_(NSRect((0,0),(50,50)))
+        self.view.setMaxSize_((1.0e7, 1.0e7))
+        self.view.setHorizontallyResizable_(NO)
+        self.view.setVerticallyResizable_(YES)
+        self.notifications = NotificationForwarder.create(self.view)
+        self.create_signal('changed')
+        self.create_signal('focus-out')
+        if initial_text is not None:
+            self.set_text(initial_text)
+        self.set_size(widgetconst.SIZE_NORMAL)
+
+    def set_size(self, size):
+        if size == widgetconst.SIZE_NORMAL:
+            font = NSFont.systemFontOfSize_(NSFont.systemFontSize())
+        elif size == widgetconst.SIZE_SMALL:
+            self.view.cell().setControlSize_(NSSmallControlSize)
+        else:
+            raise ValueError("Unknown size: %s" % size)
+        self.view.setFont_(font)
+
+    def viewport_created(self):
+        Widget.viewport_created(self)
+        self.notifications.connect(self.on_changed, 'NSTextDidChangeNotification')
+        self.notifications.connect(self.on_end_editing,
+                'NSControlTextDidEndEditingNotification')
+        self.invalidate_size_request()
+
+    def remove_viewport(self):
+        Widget.remove_viewport(self)
+        self.notifications.disconnect()
+
+    def focus(self):
+        if self.view.window() is not None:
+            self.view.window().makeFirstResponder_(self.view)
+
+    def set_text(self, text):
+        self.view.setString_(text)
+        self.invalidate_size_request()
+
+    def get_text(self):
+        return self.view.string()
+
+    def on_changed(self, notification):
+        self.invalidate_size_request()
+        self.emit("changed")
+
+    def on_end_editing(self, notification):
+        self.emit("focus-out")
+
+    def calc_size_request(self):
+        layout_manager = self.view.layoutManager()
+        text_container = self.view.textContainer()
+        # The next line is there just to force cocoa to layout the text
+        layout_manager.glyphRangeForTextContainer_(text_container)
+        rect = layout_manager.usedRectForTextContainer_(text_container)
+        return rect.size.width, rect.size.height
+
+    def set_editable(self, editable):
+        if editable:
+            self.view.setEditable_(YES)
+        else:
+            self.view.setEditable_(NO)
+
+
+class MiroButton(NSButton):
+
+    def initWithSignal_(self, signal):
+        self = super(MiroButton, self).init()
+        self.signal = signal
+        return self
+
+    def sendAction_to_(self, action, to):
+        # We override the Cocoa machinery here and just send it to our wrapper
+        # widget.
+        wrappermap.wrapper(self).emit(self.signal)
+        return YES
+
+class Checkbox(SizedControl):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self, text="", bold=False, color=None):
+        SizedControl.__init__(self)
+        self.create_signal('toggled')
+        self.view = MiroButton.alloc().initWithSignal_('toggled')
+        self.view.setButtonType_(NSSwitchButton)
+        self.bold = bold
+        self.title = text
+        self.font_size = NSFont.systemFontSize()
+        self.color = self.make_color(color)
+        self._set_title()
+
+    def set_size(self, size):
+        SizedControl.set_size(self, size)
+        self._set_title()
+
+    def _set_title(self):
+        if self.color is None:
+            self.view.setTitle_(self.title)
+        else:
+            attributes = {
+                NSForegroundColorAttributeName: self.color,
+                NSFontAttributeName: NSFont.systemFontOfSize_(self.font_size)
+            }
+            string = NSAttributedString.alloc().initWithString_attributes_(
+                    self.title, attributes)
+            self.view.setAttributedTitle_(string)
+
+    def calc_size_request(self):
+        if self.manual_size_request:
+            width, height = self.manual_size_request
+            if width == -1:
+                width = 10000
+            if height == -1:
+                height = 10000
+            size = self.view.cell().cellSizeForBounds_(
+                NSRect((0, 0), (width, height)))
+        else:
+            size = self.view.cell().cellSize()
+        return (size.width, size.height)
+
+    def baseline(self):
+        return -self.view.font().descender() + 1
+
+    def get_checked(self):
+        return self.view.state() == NSOnState
+
+    def set_checked(self, value):
+        if value:
+            self.view.setState_(NSOnState)
+        else:
+            self.view.setState_(NSOffState)
+
+    def enable(self):
+        SizedControl.enable(self)
+        self.view.setEnabled_(True)
+
+    def disable(self):
+        SizedControl.disable(self)
+        self.view.setEnabled_(False)
+
+    def get_text_padding(self):
+        """
+        Returns the amount of space the checkbox takes up before the label.
+        """
+        # XXX FIXME
+        return 18
+
+class Button(SizedControl):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self, label, style='normal', width=0):
+        SizedControl.__init__(self)
+        self.color = None
+        self.title = label
+        self.create_signal('clicked')
+        self.view = MiroButton.alloc().initWithSignal_('clicked')
+        self.view.setButtonType_(NSMomentaryPushInButton)
+        self._set_title()
+        self.setup_style(style)
+        self.min_width = width
+
+    def set_text(self, label):
+        self.title = label
+        self._set_title()
+
+    def set_color(self, color):
+        self.color = self.make_color(color)
+        self._set_title()
+
+    def _set_title(self):
+        if self.color is None:
+            self.view.setTitle_(self.title)
+        else:
+            attributes = {
+                NSForegroundColorAttributeName: self.color,
+                NSFontAttributeName: self.view.font()
+            }
+            string = NSAttributedString.alloc().initWithString_attributes_(
+                    self.title, attributes)
+            self.view.setAttributedTitle_(string)
+
+    def setup_style(self, style):
+        if style == 'normal':
+            self.view.setBezelStyle_(NSRoundedBezelStyle)
+            self.pad_height = 0
+            self.pad_width = 10
+            self.min_width = 112
+        elif style == 'smooth':
+            self.view.setBezelStyle_(NSRoundRectBezelStyle)
+            self.pad_width = 0
+            self.pad_height = 4
+        self.paragraph_style = NSMutableParagraphStyle.alloc().init()
+        self.paragraph_style.setAlignment_(NSCenterTextAlignment)
+
+    def make_default(self):
+        self.view.setKeyEquivalent_("\r")
+
+    def calc_size_request(self):
+        size = self.view.cell().cellSize()
+        width = max(self.min_width, size.width + self.pad_width)
+        height = size.height + self.pad_height
+        return width, height
+
+    def baseline(self):
+        return -self.view.font().descender() + 10 + self.pad_height
+
+    def enable(self):
+        SizedControl.enable(self)
+        self.view.setEnabled_(True)
+
+    def disable(self):
+        SizedControl.disable(self)
+        self.view.setEnabled_(False)
+
+class MiroPopupButton(NSPopUpButton):
+
+    def init(self):
+        self = super(MiroPopupButton, self).init()
+        self.setTarget_(self)
+        self.setAction_('handleChange:')
+        return self
+
+    def handleChange_(self, sender):
+        wrappermap.wrapper(self).emit('changed', self.indexOfSelectedItem())
+
+class OptionMenu(SizedControl):
+    def __init__(self, options):
+        SizedControl.__init__(self)
+        self.create_signal('changed')
+        self.view = MiroPopupButton.alloc().init()
+        self.options = options
+        for option, value in options:
+            self.view.addItemWithTitle_(option)
+
+    def baseline(self):
+        if self.view.cell().controlSize() == NSRegularControlSize:
+            return -self.view.font().descender() + 6
+        else:
+            return -self.view.font().descender() + 5
+
+    def calc_size_request(self):
+        return self.view.cell().cellSize()
+
+    def set_selected(self, index):
+        self.view.selectItemAtIndex_(index)
+
+    def get_selected(self):
+        return self.view.indexOfSelectedItem()
+
+    def enable(self):
+        SizedControl.enable(self)
+        self.view.setEnabled_(True)
+
+    def disable(self):
+        SizedControl.disable(self)
+        self.view.setEnabled_(False)
+
+    def set_width(self, width):
+        # TODO
+        pass
+
+class RadioButtonGroup:
+    def __init__(self):
+        self._buttons = []
+
+    def handle_click(self, widget):
+        self.set_selected(widget)
+
+    def add_button(self, button):
+        self._buttons.append(button)
+        button.connect('clicked', self.handle_click)
+        if len(self._buttons) == 1:
+            button.view.setState_(NSOnState)
+        else:
+            button.view.setState_(NSOffState)
+
+    def get_buttons(self):
+        return self._buttons
+
+    def get_selected(self):
+        for mem in self._buttons:
+            if mem.get_selected():
+                return mem
+
+    def set_selected(self, button):
+        for mem in self._buttons:
+            if button is mem:
+                mem.view.setState_(NSOnState)
+            else:
+                mem.view.setState_(NSOffState)
+
+class RadioButton(SizedControl):
+    def __init__(self, label, group=None, bold=False, color=None):
+        SizedControl.__init__(self)
+        self.create_signal('clicked')
+        self.view = MiroButton.alloc().initWithSignal_('clicked')
+        self.view.setButtonType_(NSRadioButton)
+        self.color = self.make_color(color)
+        self.title = label
+        self.bold = bold
+        self.font_size = NSFont.systemFontSize()
+        self._set_title()
+
+        if group is not None:
+            self.group = group
+        else:
+            self.group = RadioButtonGroup()
+
+        self.group.add_button(self)
+
+    def set_size(self, size):
+        SizedControl.set_size(self, size)
+        self._set_title()
+
+    def _set_title(self):
+        if self.color is None:
+            self.view.setTitle_(self.title)
+        else:
+            attributes = {
+                NSForegroundColorAttributeName: self.color,
+                NSFontAttributeName: NSFont.systemFontOfSize_(self.font_size)
+            }
+            string = NSAttributedString.alloc().initWithString_attributes_(
+                    self.title, attributes)
+            self.view.setAttributedTitle_(string)
+
+    def calc_size_request(self):
+        size = self.view.cell().cellSize()
+        return (size.width, size.height)
+
+    def baseline(self):
+        -self.view.font().descender() + 2
+
+    def get_group(self):
+        return self.group
+
+    def get_selected(self):
+        return self.view.state() == NSOnState
+
+    def set_selected(self):
+        self.group.set_selected(self)
+
+    def enable(self):
+        SizedControl.enable(self)
+        self.view.setEnabled_(True)
+
+    def disable(self):
+        SizedControl.disable(self)
+        self.view.setEnabled_(False)
diff --git a/lvc/widgets/osx/customcontrol.py b/lvc/widgets/osx/customcontrol.py
new file mode 100644
index 0000000..4a32b8e
--- /dev/null
+++ b/lvc/widgets/osx/customcontrol.py
@@ -0,0 +1,436 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".customcontrol -- CustomControl handlers.  """
+
+import collections
+
+from AppKit import *
+from Foundation import *
+from objc import YES, NO, nil
+
+from lvc.widgets import widgetconst
+import wrappermap
+from .base import Widget
+import drawing
+from .layoutmanager import LayoutManager
+
+class DrawableButtonCell(NSButtonCell):
+    def startTrackingAt_inView_(self, point, view):
+        view.setState_(NSOnState)
+        return YES
+
+    def continueTracking_at_inView_(self, lastPoint, at, view):
+        view.setState_(NSOnState)
+        return YES
+
+    def stopTracking_at_inView_mouseIsUp_(self, lastPoint, at, view, mouseIsUp):
+        if not mouseIsUp:
+            view.mouse_inside = False
+            view.setState_(NSOffState)
+
+class DrawableButton(NSButton):
+    def init(self):
+        self = super(DrawableButton, self).init()
+        self.layout_manager = LayoutManager()
+        self.tracking_area = None
+        self.mouse_inside = False
+        self.custom_cursor = None
+        return self
+
+    def resetCursorRects(self):
+        if self.custom_cursor is not None:
+            self.addCursorRect_cursor_(self.visibleRect(), self.custom_cursor)
+            self.custom_cursor.setOnMouseEntered_(YES)
+
+    def updateTrackingAreas(self):
+        # remove existing tracking area if needed
+        if self.tracking_area:
+            self.removeTrackingArea_(self.tracking_area)
+
+        # create a new tracking area for the entire view.  This allows us to
+        # get mouseMoved events whenever the mouse is inside our view.
+        self.tracking_area = NSTrackingArea.alloc()
+        self.tracking_area.initWithRect_options_owner_userInfo_(
+                self.visibleRect(),
+                NSTrackingMouseEnteredAndExited | NSTrackingMouseMoved |
+                NSTrackingActiveInKeyWindow,
+                self,
+                nil)
+        self.addTrackingArea_(self.tracking_area)
+
+    def mouseEntered_(self, event):
+        window = self.window()
+        if window is not nil and window.isMainWindow():
+            self.mouse_inside = True
+            self.setNeedsDisplay_(YES)
+
+    def mouseExited_(self, event):
+        window = self.window()
+        if window is not nil and window.isMainWindow():
+            self.mouse_inside = False
+            self.setNeedsDisplay_(YES)
+
+    def isOpaque(self):
+        return wrappermap.wrapper(self).is_opaque()
+
+    def drawRect_(self, rect):
+        context = drawing.DrawingContext(self, self.bounds(), rect)
+        context.style = drawing.DrawingStyle()
+        wrapper = wrappermap.wrapper(self)
+        wrapper.state = 'normal'
+        disabled = wrapper.get_disabled()
+        if not disabled:
+            if self.state() == NSOnState:
+                wrapper.state = 'pressed'
+            elif self.mouse_inside:
+                wrapper.state = 'hover'
+            else:
+                wrapper.state = 'normal'
+
+        wrapper.draw(context, self.layout_manager)
+        self.layout_manager.reset()
+
+    def sendAction_to_(self, action, to):
+        # We override the Cocoa machinery here and just send it to our wrapper
+        # widget.
+        wrapper = wrappermap.wrapper(self)
+        disabled = wrapper.get_disabled()
+        if not disabled:
+            wrapper.emit('clicked')
+        # Tell Cocoa we handled it anyway, just not emit the actual clicked
+        # event.
+        return YES
+DrawableButton.setCellClass_(DrawableButtonCell)
+
+class ContinousButtonCell(DrawableButtonCell):
+    def stopTracking_at_inView_mouseIsUp_(self, lastPoint, at, view, mouseIsUp):
+        view.onStopTracking(at)
+        NSButtonCell.stopTracking_at_inView_mouseIsUp_(self, lastPoint, at,
+                view, mouseIsUp)
+
+class ContinuousDrawableButton(DrawableButton):
+    def init(self):
+        self = super(ContinuousDrawableButton, self).init()
+        self.setContinuous_(YES)
+        return self
+
+    def mouseDown_(self, event):
+        self.releaseInbounds = self.stopTracking = self.firedOnce = False
+        self.cell().trackMouse_inRect_ofView_untilMouseUp_(event,
+                self.bounds(), self, YES)
+        wrapper = wrappermap.wrapper(self)
+        if not wrapper.get_disabled():
+            if self.firedOnce:
+                wrapper.emit('released')
+            elif self.releaseInbounds:
+                wrapper.emit('clicked')
+
+    def sendAction_to_(self, action, to):
+        if self.stopTracking:
+            return NO
+        self.firedOnce = True
+        wrapper = wrappermap.wrapper(self)
+        if not wrapper.get_disabled():
+            wrapper.emit('held-down')
+        return YES
+
+    def onStopTracking(self, mouseLocation):
+        self.releaseInbounds = NSPointInRect(mouseLocation, self.bounds())
+        self.stopTracking = True
+ContinuousDrawableButton.setCellClass_(ContinousButtonCell)
+
+class DragableButtonCell(NSButtonCell):
+    def startTrackingAt_inView_(self, point, view):
+        self.start_x = point.x
+        return YES
+
+    def continueTracking_at_inView_(self, lastPoint, at, view):
+        DRAG_THRESHOLD = 15
+        wrapper = wrappermap.wrapper(view)
+        if not wrapper.get_disabled():
+            if (view.last_drag_event != 'right' and
+                    at.x > self.start_x + DRAG_THRESHOLD):
+                wrapper.emit("dragged-right")
+                view.last_drag_event = 'right'
+            elif (view.last_drag_event != 'left' and
+                    at.x < self.start_x - DRAG_THRESHOLD):
+                view.last_drag_event = 'left'
+                wrapper.emit("dragged-left")
+        return YES
+
+class DragableDrawableButton(DrawableButton):
+    def mouseDown_(self, event):
+        self.last_drag_event = None
+        self.cell().trackMouse_inRect_ofView_untilMouseUp_(event,
+                self.bounds(), self, YES)
+
+    def sendAction_to_(self, action, to):
+        # only send the click event if we didn't send a
+        # dragged-left/dragged-right event
+        wrapper = wrappermap.wrapper(self)
+        if self.last_drag_event is None and not wrapper.get_disabled():
+            wrapper.emit('clicked')
+        return YES
+DragableDrawableButton.setCellClass_(DragableButtonCell)
+
+MouseTrackingInfo = collections.namedtuple("MouseTrackingInfo",
+                                           "start_pos click_pos")
+
+class CustomSliderCell(NSSliderCell):
+    def calc_slider_amount(self, view, pos, size):
+        slider_size = wrappermap.wrapper(view).slider_size()
+        pos -= slider_size / 2
+        size -= slider_size
+        return max(0, min(1, float(pos) / size))
+
+    def get_slider_pos(self, view, value=None):
+        if value is None:
+            value = view.floatValue()
+        if view.isVertical():
+            size = view.bounds().size.height
+        else:
+            size = view.bounds().size.width
+        slider_size = view.knobThickness()
+        size -= slider_size
+        start_pos = slider_size / 2.0
+        ratio = ((value - view.minValue()) /
+                 view.maxValue() - view.minValue())
+        return start_pos + (ratio * size)
+
+    def startTrackingAt_inView_(self, at, view):
+        wrapper = wrappermap.wrapper(view)
+        start_pos = self.get_slider_pos(view)
+        if self.isVertical():
+            click_pos = at.y
+        else:
+            click_pos = at.x
+        # only move the cursor if the click was outside the slider
+        if abs(click_pos - start_pos) > view.knobThickness() / 2:
+            self.moveSliderTo(view, click_pos)
+            start_pos = click_pos
+        view.mouse_tracking_info = MouseTrackingInfo(start_pos, click_pos)
+        if not wrapper.get_disabled():
+            wrapper.emit('pressed')
+        return YES
+
+    def moveSliderTo(self, view, pos):
+        if view.isVertical():
+            size = view.bounds().size.height
+        else:
+            size = view.bounds().size.width
+
+        slider_amount = self.calc_slider_amount(view, pos, size)
+        value = (self.maxValue() - self.minValue()) * slider_amount
+        self.setFloatValue_(value)
+        wrapper = wrappermap.wrapper(view)
+        if not wrapper.get_disabled():
+            wrapper.emit('moved', value)
+            if self.isContinuous():
+                wrapper.emit('changed', value)
+
+    def continueTracking_at_inView_(self, lastPoint, at, view):
+        if view.isVertical():
+            mouse_pos = at.y
+        else:
+            mouse_pos = at.x
+
+        info = view.mouse_tracking_info
+        new_pos = info.start_pos + (mouse_pos - info.click_pos)
+        self.moveSliderTo(view, new_pos)
+        return YES
+
+    def stopTracking_at_inView_mouseIsUp_(self, lastPoint, at, view, mouseUp):
+        wrapper = wrappermap.wrapper(view)
+        if not wrapper.get_disabled():
+            wrapper.emit('released')
+        view.mouse_tracking_info = None
+
+class CustomSliderView(NSSlider):
+    def init(self):
+        self = super(CustomSliderView, self).init()
+        self.layout_manager = LayoutManager()
+        self.custom_cursor = None
+        self.mouse_tracking_info = None
+        return self
+
+    def get_slider_pos(self, value=None):
+        return self.cell().get_slider_pos(self, value)
+
+    def resetCursorRects(self):
+        if self.custom_cursor is not None:
+            self.addCursorRect_cursor_(self.visibleRect(), self.custom_cursor)
+            self.custom_cursor.setOnMouseEntered_(YES)
+
+    def isOpaque(self):
+        return wrappermap.wrapper(self).is_opaque()
+
+    def knobThickness(self):
+        return wrappermap.wrapper(self).slider_size()
+
+    def scrollWheel_(self, event):
+        wrapper = wrappermap.wrapper(self)
+        if wrapper.get_disabled():
+            return
+        # NOTE: we ignore the scroll_step value passed into set_increments()
+        # and calculate the change using deltaY, which is in device
+        # coordinates.
+        slider_size = wrapper.slider_size()
+        if wrapper.is_horizontal():
+            size = self.bounds().size.width
+        else:
+            size = self.bounds().size.height
+        size -= slider_size
+
+        range = self.maxValue() - self.minValue()
+        value_change = (event.deltaY() / size) * range
+        self.setFloatValue_(self.floatValue() + value_change)
+        wrapper.emit('pressed')
+        wrapper.emit('changed', self.floatValue())
+        wrapper.emit('released')
+
+    def isVertical(self):
+        return not wrappermap.wrapper(self).is_horizontal()
+
+    def drawRect_(self, rect):
+        context = drawing.DrawingContext(self, self.bounds(), rect)
+        context.style = drawing.DrawingStyle()
+        wrappermap.wrapper(self).draw(context, self.layout_manager)
+        self.layout_manager.reset()
+
+    def sendAction_to_(self, action, to):
+        # We override the Cocoa machinery here and just send it to our wrapper
+        # widget.
+        wrapper = wrappermap.wrapper(self)
+        disabled = wrapper.get_disabled()
+        if not disabled:
+            wrapper.emit('changed', self.floatValue())
+        # Total Cocoa we handled it anyway to prevent the event passed to
+        # upper layer.
+        return YES
+CustomSliderView.setCellClass_(CustomSliderCell)
+
+class CustomControlBase(drawing.DrawingMixin, Widget):
+    def set_cursor(self, cursor):
+        if cursor == widgetconst.CURSOR_NORMAL:
+            self.view.custom_cursor = None
+        elif cursor == widgetconst.CURSOR_POINTING_HAND:
+            self.view.custom_cursor = NSCursor.pointingHandCursor()
+        else:
+            raise ValueError("Unknown cursor: %s" % cursor)
+        if self.view.window():
+            self.view.window().invalidateCursorRectsForView_(self.view)
+
+class CustomButton(CustomControlBase):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self):
+        CustomControlBase.__init__(self)
+        self.create_signal('clicked')
+        self.view = DrawableButton.alloc().init()
+        self.view.setRefusesFirstResponder_(NO)
+        self.view.setEnabled_(True)
+
+    def enable(self):
+        Widget.enable(self)
+        self.view.setNeedsDisplay_(YES)
+
+    def disable(self):
+        Widget.disable(self)
+        self.view.setNeedsDisplay_(YES)
+
+class ContinuousCustomButton(CustomButton):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self):
+        CustomButton.__init__(self)
+        self.create_signal('held-down')
+        self.create_signal('released')
+        self.view = ContinuousDrawableButton.alloc().init()
+        self.view.setRefusesFirstResponder_(NO)
+
+    def set_delays(self, initial, repeat):
+        self.view.cell().setPeriodicDelay_interval_(initial, repeat)
+
+class DragableCustomButton(CustomButton):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self):
+        CustomButton.__init__(self)
+        self.create_signal('dragged-left')
+        self.create_signal('dragged-right')
+        self.view = DragableDrawableButton.alloc().init()
+
+class CustomSlider(CustomControlBase):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self):
+        CustomControlBase.__init__(self)
+        self.create_signal('pressed')
+        self.create_signal('released')
+        self.create_signal('changed')
+        self.create_signal('moved')
+        self.view = CustomSliderView.alloc().init()
+        self.view.setRefusesFirstResponder_(NO)
+        if self.is_continuous():
+            self.view.setContinuous_(YES)
+        else:
+            self.view.setContinuous_(NO)
+        self.view.setEnabled_(True)
+
+    def get_slider_pos(self, value=None):
+        return self.view.get_slider_pos(value)
+
+    def viewport_created(self):
+        self.view.cell().setKnobThickness_(self.slider_size())
+
+    def get_value(self):
+        return self.view.floatValue()
+
+    def set_value(self, value):
+        self.view.setFloatValue_(value)
+
+    def get_range(self):
+        return self.view.minValue(), self.view.maxValue()
+
+    def set_range(self, min_value, max_value):
+        self.view.setMinValue_(min_value)
+        self.view.setMaxValue_(max_value)
+
+    def set_increments(self, small_step, big_step, scroll_step=None):
+        # NOTE: we ignore all of these parameters.
+        #
+        # Cocoa doesn't have a concept of changing the increments for
+        # NSScroller.  scroll_step is isn't really compatible with
+        # the event object that's passed to scrollWheel_()
+        pass
+
+    def enable(self):
+        Widget.enable(self)
+        self.view.setNeedsDisplay_(YES)
+
+    def disable(self):
+        Widget.disable(self)
+        self.view.setNeedsDisplay_(YES)
diff --git a/lvc/widgets/osx/drawing.py b/lvc/widgets/osx/drawing.py
new file mode 100644
index 0000000..aaad1e9
--- /dev/null
+++ b/lvc/widgets/osx/drawing.py
@@ -0,0 +1,289 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""miro.plat.frontend.widgets.drawing -- Draw on Views."""
+
+import math
+
+from Foundation import *
+from AppKit import *
+#from Quartz import *
+from objc import YES, NO, nil
+
+
+class ImageSurface:
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self, image):
+        """Create a new ImageSurface."""
+        self.image = image.nsimage.copy()
+        self.width = image.width
+        self.height = image.height
+
+    def get_size(self):
+        return self.width, self.height
+
+    def draw(self, context, x, y, width, height, fraction=1.0):
+        if self.width == 0 or self.height == 0:
+            return
+        current_context = NSGraphicsContext.currentContext()
+        current_context.setShouldAntialias_(YES)
+        current_context.setImageInterpolation_(NSImageInterpolationHigh)
+        current_context.saveGraphicsState()
+        flip_context(y + height)
+        dest_rect = NSMakeRect(x, 0, width, height)
+        if self.width >= width and self.height >= height:
+            # drawing to area smaller than our image
+            source_rect = NSMakeRect(0, 0, width, height)
+            self.image.drawInRect_fromRect_operation_fraction_(
+                dest_rect, source_rect, NSCompositeSourceOver, fraction)
+        else:
+            # drawing to area larger than our image.  Need to tile it.
+            NSColor.colorWithPatternImage_(self.image).set()
+            current_context.setPatternPhase_(
+                    self._calc_pattern_phase(context, x, y))
+            NSBezierPath.fillRect_(dest_rect)
+        current_context.restoreGraphicsState()
+
+    def draw_rect(self, context, dest_x, dest_y, source_x, source_y, width,
+            height, fraction=1.0):
+        if width == 0 or height == 0:
+            return
+        current_context = NSGraphicsContext.currentContext()
+        current_context.setShouldAntialias_(YES)
+        current_context.setImageInterpolation_(NSImageInterpolationHigh)
+        current_context.saveGraphicsState()
+        flip_context(dest_y + height)
+        dest_y = 0
+        dest_rect = NSMakeRect(dest_x, dest_y, width, height)
+        source_rect = NSMakeRect(source_x, self.height-source_y-height,
+                                 width, height)
+        self.image.drawInRect_fromRect_operation_fraction_(
+                dest_rect, source_rect, NSCompositeSourceOver, fraction)
+        current_context.restoreGraphicsState()
+
+    def _calc_pattern_phase(self, context, x, y):
+        """Calculate the pattern phase to draw tiled images.
+
+        When we draw with a pattern, we want the image in the pattern to start
+        at the top-left of where we're drawing to.  This function does the
+        dirty work necessary.
+
+        :returns: NSPoint to send to setPatternPhase_
+        """
+        # convert to view coords
+        view_point = NSPoint(context.origin.x + x, context.origin.y + y)
+        # convert to window coords, which is setPatternPhase_ uses
+        return context.view.convertPoint_toView_(view_point, nil)
+
+def convert_cocoa_color(color):
+    rgb = color.colorUsingColorSpaceName_(NSDeviceRGBColorSpace)
+    return (rgb.redComponent(), rgb.greenComponent(), rgb.blueComponent())
+
+def convert_widget_color(color, alpha=1.0):
+    return NSColor.colorWithDeviceRed_green_blue_alpha_(color[0], color[1],
+                                                        color[2], alpha)
+def flip_context(height):
+    """Make the current context's coordinates flipped.
+
+    This is useful for drawing images, since they use the normal cocoa
+    coordinates and we use flipped versions.
+
+    :param height: height of the current area we are drawing to.
+    """
+    xform = NSAffineTransform.transform()
+    xform.translateXBy_yBy_(0, height)
+    xform.scaleXBy_yBy_(1.0, -1.0)
+    xform.concat()
+
+class DrawingStyle(object):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self, bg_color=None, text_color=None):
+        self.use_custom_style = True
+        if text_color is None:
+            self.text_color = self.default_text_color
+        else:
+            self.text_color = convert_cocoa_color(text_color)
+        if bg_color is None:
+            self.bg_color = self.default_bg_color
+        else:
+            self.bg_color = convert_cocoa_color(bg_color)
+
+    default_text_color = convert_cocoa_color(NSColor.textColor())
+    default_bg_color = convert_cocoa_color(NSColor.textBackgroundColor())
+
+class DrawingContext:
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self, view, drawing_area, rect):
+        self.view = view
+        self.path = NSBezierPath.bezierPath()
+        self.color = NSColor.blackColor()
+        self.width = drawing_area.size.width
+        self.height = drawing_area.size.height
+        self.origin = drawing_area.origin
+        if drawing_area.origin != NSZeroPoint:
+            xform = NSAffineTransform.transform()
+            xform.translateXBy_yBy_(drawing_area.origin.x,
+                    drawing_area.origin.y)
+            xform.concat()
+
+    def move_to(self, x, y):
+        self.path.moveToPoint_(NSPoint(x, y))
+
+    def rel_move_to(self, dx, dy):
+        self.path.relativeMoveToPoint_(NSPoint(dx, dy))
+
+    def line_to(self, x, y):
+        self.path.lineToPoint_(NSPoint(x, y))
+
+    def rel_line_to(self, dx, dy):
+        self.path.relativeLineToPoint_(NSPoint(dx, dy))
+
+    def curve_to(self, x1, y1, x2, y2, x3, y3):
+        self.path.curveToPoint_controlPoint1_controlPoint2_(
+                NSPoint(x3, y3), NSPoint(x1, y1), NSPoint(x2, y2))
+
+    def rel_curve_to(self, dx1, dy1, dx2, dy2, dx3, dy3):
+        self.path.relativeCurveToPoint_controlPoint1_controlPoint2_(
+                NSPoint(dx3, dy3), NSPoint(dx1, dy1), NSPoint(dx2, dy2))
+
+    def arc(self, x, y, radius, angle1, angle2):
+        angle1 = (angle1 * 360) / (2 * math.pi)
+        angle2 = (angle2 * 360) / (2 * math.pi)
+        center = NSPoint(x, y)
+        self.path.appendBezierPathWithArcWithCenter_radius_startAngle_endAngle_(center, radius, angle1, angle2)
+
+    def arc_negative(self, x, y, radius, angle1, angle2):
+        angle1 = (angle1 * 360) / (2 * math.pi)
+        angle2 = (angle2 * 360) / (2 * math.pi)
+        center = NSPoint(x, y)
+        self.path.appendBezierPathWithArcWithCenter_radius_startAngle_endAngle_clockwise_(center, radius, angle1, angle2, YES)
+
+    def rectangle(self, x, y, width, height):
+        rect = NSMakeRect(x, y, width, height)
+        self.path.appendBezierPathWithRect_(rect)
+
+    def set_color(self, color, alpha=1.0):
+        self.color = convert_widget_color(color, alpha)
+        self.color.set()
+
+    def set_shadow(self, color, opacity, offset, blur_radius):
+        shadow = NSShadow.alloc().init()
+        # shadow offset is always in the cocoa coordinates, so we need to
+        # reverse the y part
+        shadow.setShadowOffset_(NSPoint(offset[0], -offset[1]))
+        shadow.setShadowBlurRadius_(blur_radius)
+        shadow.setShadowColor_(convert_widget_color(color, opacity))
+        shadow.set()
+
+    def set_line_width(self, width):
+        self.path.setLineWidth_(width)
+
+    def stroke(self):
+        self.path.stroke()
+        self.path.removeAllPoints()
+
+    def stroke_preserve(self):
+        self.path.stroke()
+
+    def fill(self):
+        self.path.fill()
+        self.path.removeAllPoints()
+
+    def fill_preserve(self):
+        self.path.fill()
+
+    def clip(self):
+        self.path.addClip()
+        self.path.removeAllPoints()
+
+    def save(self):
+        NSGraphicsContext.currentContext().saveGraphicsState()
+
+    def restore(self):
+        NSGraphicsContext.currentContext().restoreGraphicsState()
+
+    def gradient_fill(self, gradient):
+        self.gradient_fill_preserve(gradient)
+        self.path.removeAllPoints()
+
+    def gradient_fill_preserve(self, gradient):
+        context = NSGraphicsContext.currentContext()
+        context.saveGraphicsState()
+        self.path.addClip()
+        gradient.draw()
+        context.restoreGraphicsState()
+
+class Gradient(object):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self, x1, y1, x2, y2):
+        self.x1, self.y1, self.x2, self.y2 = x1, y1, x2, y2
+        self.start_color = None
+        self.end_color = None
+
+    def set_start_color(self, (red, green, blue)):
+        self.start_color = (red, green, blue)
+
+    def set_end_color(self, (red, green, blue)):
+        self.end_color = (red, green, blue)
+
+    def draw(self):
+        start_color = convert_widget_color(self.start_color)
+        end_color = convert_widget_color(self.end_color)
+        nsgradient = NSGradient.alloc().initWithStartingColor_endingColor_(start_color, end_color)
+        start_point = NSPoint(self.x1, self.y1)
+        end_point = NSPoint(self.x2, self.y2)
+        nsgradient.drawFromPoint_toPoint_options_(start_point, end_point, 0)
+
+class DrawingMixin(object):
+    def calc_size_request(self):
+        return self.size_request(self.view.layout_manager)
+
+    # squish width / squish height only make sense on GTK
+    def set_squish_width(self, setting):
+        pass
+
+    def set_squish_height(self, setting):
+        pass
+
+    # Default implementations for methods that subclasses override.
+
+    def is_opaque(self):
+        return False
+
+    def size_request(self, layout_manager):
+        return 0, 0
+
+    def draw(self, context, layout_manager):
+        pass
+
+    def viewport_repositioned(self):
+        # since this is a Mixin class, we want to make sure that our other
+        # classes see the viewport_repositioned() call.
+        super(DrawingMixin, self).viewport_repositioned()
+        self.queue_redraw()
diff --git a/lvc/widgets/osx/drawingwidgets.py b/lvc/widgets/osx/drawingwidgets.py
new file mode 100644
index 0000000..74e8232
--- /dev/null
+++ b/lvc/widgets/osx/drawingwidgets.py
@@ -0,0 +1,67 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""drawingviews.py -- views that support custom drawing."""
+
+import wrappermap
+import drawing
+from .base import Widget, SimpleBin, FlippedView
+from .layoutmanager import LayoutManager
+
+class DrawingView(FlippedView):
+    def init(self):
+        self = super(DrawingView, self).init()
+        self.layout_manager = LayoutManager()
+        return self
+
+    def isOpaque(self):
+        return wrappermap.wrapper(self).is_opaque()
+
+    def drawRect_(self, rect):
+        context = drawing.DrawingContext(self, self.bounds(), rect)
+        context.style = drawing.DrawingStyle()
+        wrappermap.wrapper(self).draw(context, self.layout_manager)
+
+class DrawingArea(drawing.DrawingMixin, Widget):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self):
+        Widget.__init__(self)
+        self.view = DrawingView.alloc().init()
+
+class Background(drawing.DrawingMixin, SimpleBin):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self):
+        SimpleBin.__init__(self)
+        self.view = DrawingView.alloc().init()
+
+    def calc_size_request(self):
+        drawing_size = drawing.DrawingMixin.calc_size_request(self)
+        container_size = SimpleBin.calc_size_request(self)
+        return (max(container_size[0], drawing_size[0]),
+                max(container_size[1], drawing_size[1]))
diff --git a/lvc/widgets/osx/fasttypes.c b/lvc/widgets/osx/fasttypes.c
new file mode 100644
index 0000000..72d3b5b
--- /dev/null
+++ b/lvc/widgets/osx/fasttypes.c
@@ -0,0 +1,540 @@
+/*
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+ */
+
+#include <Python.h>
+
+/*
+ * fasttypes.c
+ *
+ * Datastructures written in C to be fast.  This used to be a big C++ file
+ * that depended on boost.  Nowadays we only define LinkedList, which is easy
+ * enough to implement in pure C.
+ */
+
+static int nodes_deleted = 0; // debugging only
+
+/* forward define python type objects */
+
+static PyTypeObject LinkedListType;
+static PyTypeObject LinkedListIterType;
+
+/* Structure definitions */
+
+typedef struct LinkedListNode {
+    PyObject *obj;
+    struct LinkedListNode* next;
+    struct LinkedListNode* prev;
+    int deleted; // Has this node been removed?
+    int iter_count; // How many LinkedListIters point to this node?
+} LinkedListNode;
+
+typedef struct {
+    PyObject_HEAD
+    int count;
+    LinkedListNode* sentinal;
+    // sentinal object to make list operations simpler/faster and equivalent
+    // to the boost API.  It's prev node is the last element in the list and
+    // it's next node is the first
+} LinkedListObject;
+
+typedef struct {
+    PyObject_HEAD
+    LinkedListNode* node;
+    LinkedListObject* list;
+} LinkedListIterObject;
+
+/* LinkedListNode */
+
+void check_node_deleted(LinkedListNode* node)
+{
+    if(node->iter_count <= 0 && node->deleted) {
+        free(node);
+        nodes_deleted += 1;
+    }
+}
+
+static int remove_node(LinkedListObject* self, LinkedListNode* node)
+{
+    if(node->obj == NULL) {
+        PyErr_SetString(PyExc_IndexError, "can't remove lastIter()");
+        return 0;
+    }
+    node->next->prev = node->prev;
+    node->prev->next = node->next;
+    node->deleted = 1;
+    self->count -= 1;
+    Py_DECREF(node->obj);
+    check_node_deleted(node);
+    return 1;
+}
+
+/* LinkedListIter */
+
+void switch_node(LinkedListIterObject* self, LinkedListNode* new_node)
+{
+    LinkedListNode* old_node;
+
+    old_node = self->node;
+    self->node = new_node;
+    old_node->iter_count--;
+    self->node->iter_count++;
+    check_node_deleted(old_node);
+}
+
+// Note that we don't expose the new method to python.  We create
+// LinkedListIters in the factory methods firstIter() and lastIter()
+static LinkedListIterObject* LinkedListIterObject_new(LinkedListObject*list,
+        LinkedListNode* node)
+{
+    LinkedListIterObject* self;
+
+    self = (LinkedListIterObject*)PyType_GenericAlloc(&LinkedListIterType, 0);
+    if(self != NULL) {
+        self->node = node;
+        self->list = list;
+        node->iter_count++;
+    }
+    return self;
+}
+
+static void LinkedListIterObject_dealloc(LinkedListIterObject* self)
+{
+    self->node->iter_count--;
+    check_node_deleted(self->node);
+}
+
+static PyObject *LinkedListIter_forward(LinkedListIterObject* self, PyObject *obj)
+{
+    switch_node(self, self->node->next);
+    Py_RETURN_NONE;
+}
+
+static PyObject *LinkedListIter_back(LinkedListIterObject* self, PyObject *obj)
+{
+    switch_node(self, self->node->prev);
+    Py_RETURN_NONE;
+}
+
+static PyObject *LinkedListIter_value(LinkedListIterObject* self, PyObject *obj)
+{
+    PyObject* retval;
+
+    if(self->node->deleted) {
+        PyErr_SetString(PyExc_ValueError, "Node deleted");
+        return NULL;
+    }
+    retval = self->node->obj;
+    if(retval == NULL) {
+        PyErr_SetString(PyExc_IndexError, "can't get value of lastIter()");
+        return NULL;
+    }
+    Py_INCREF(retval);
+    return retval;
+}
+
+static PyObject *LinkedListIter_copy(LinkedListIterObject* self, PyObject *obj)
+{
+    return (PyObject*)LinkedListIterObject_new(self->list, self->node);
+}
+
+static PyObject *LinkedListIter_valid(LinkedListIterObject* self, PyObject *obj)
+{
+    return PyBool_FromLong(self->node->deleted == 0);
+}
+
+PyObject* LinkedListIter_richcmp(LinkedListIterObject *o1,
+        LinkedListIterObject *o2, int opid)
+{
+    if(!PyObject_TypeCheck(o1, &LinkedListIterType) ||
+        !PyObject_TypeCheck(o2, &LinkedListIterType)) {
+        return Py_NotImplemented;
+    }
+    switch(opid) {
+        case Py_EQ:
+            if(o1->node == o2->node) Py_RETURN_TRUE;
+            else Py_RETURN_FALSE;
+        case Py_NE:
+            if(o1->node != o2->node) Py_RETURN_TRUE;
+            else Py_RETURN_FALSE;
+        default:
+            return Py_NotImplemented;
+    }
+}
+
+static PyMethodDef LinkedListIter_methods[] = {
+    {"forward", (PyCFunction)LinkedListIter_forward, METH_NOARGS,
+             "Move to the next element",
+    },
+    {"back", (PyCFunction)LinkedListIter_back, METH_NOARGS,
+             "Move to the previous element",
+    },
+    {"value", (PyCFunction)LinkedListIter_value, METH_NOARGS,
+             "Return the current element",
+    },
+    {"copy", (PyCFunction)LinkedListIter_copy, METH_NOARGS,
+             "Duplicate iter",
+    },
+    {"valid", (PyCFunction)LinkedListIter_valid, METH_NOARGS,
+             "Test if the iter is valid",
+    },
+    {NULL},
+};
+
+static PyTypeObject LinkedListIterType = {
+    PyObject_HEAD_INIT(NULL)
+    0,                                 /* ob_size */
+    "fasttypes.LinkedListIter",            /* tp_name */
+    sizeof(LinkedListIterObject),          /* tp_basicsize */
+    0,                                 /* tp_itemsize */
+    (destructor)LinkedListIterObject_dealloc,      /* tp_dealloc */
+    0,                                 /* tp_print */
+    0,                                 /* tp_getattr */
+    0,                                 /* tp_setattr */
+    0,                                 /* tp_compare */
+    0,                                 /* tp_repr */
+    0,                                 /* tp_as_number */
+    0,                                 /* tp_as_sequence */
+    0,                                 /* tp_as_mapping */
+    0,                                 /* tp_hash  */
+    0,                                 /* tp_call */
+    0,                                 /* tp_str */
+    0,                                 /* tp_getattro */
+    0,                                 /* tp_setattro */
+    0,                                 /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_RICHCOMPARE, /* tp_flags */
+    "fasttypes LinkedListIter",        /* tp_doc */
+    0,                                 /* tp_traverse */
+    0,                                 /* tp_clear */
+    (richcmpfunc)LinkedListIter_richcmp,            /* tp_richcompare */
+    0,                                 /* tp_weaklistoffset */
+    0,                                 /* tp_iter */
+    0,                                 /* tp_iternext */
+    LinkedListIter_methods,           /* tp_methods */
+    0,                                 /* tp_members */
+    0,                                 /* tp_getset */
+    0,                                 /* tp_base */
+    0,                                 /* tp_dict */
+    0,                                 /* tp_descr_get */
+    0,                                 /* tp_descr_set */
+    0,                                 /* tp_dictoffset */
+    0,                                 /* tp_init */
+    0,                                 /* tp_alloc */
+    0,                                 /* tp_new */
+};
+
+/* LinkedList */
+
+LinkedListNode* make_new_node(PyObject* obj, LinkedListNode* prev,
+        LinkedListNode* next)
+{
+    LinkedListNode* retval;
+    retval = malloc(sizeof(LinkedListNode));
+    if(!retval) {
+        PyErr_SetString(PyExc_MemoryError, "can't create new node");
+        return NULL;
+    }
+    Py_XINCREF(obj);
+    retval->obj = obj;
+    retval->prev = prev;
+    retval->next = next;
+    retval->iter_count = retval->deleted = 0;
+    return retval;
+}
+
+void set_iter_type_error(PyObject* obj)
+{
+    // Set an exception when we expected a LinkedListIter and got something
+    // else
+    PyObject* args;
+    PyObject* fmt;
+    PyObject* err_str;
+
+    args = Py_BuildValue("(O)", obj);
+    fmt = PyString_FromString("Expected LinkedListIter, got %r");
+    err_str = PyString_Format(fmt, args);
+    PyErr_SetObject(PyExc_TypeError, err_str);
+    Py_DECREF(fmt);
+    Py_DECREF(err_str);
+    Py_DECREF(args);
+}
+
+static PyObject* insert_before(LinkedListObject* self, LinkedListNode* node,
+        PyObject* obj)
+{
+    LinkedListNode* new_node;
+    PyObject* retval;
+
+    new_node = make_new_node(obj, node->prev, node);
+    if(!new_node) return NULL;
+    node->prev->next = new_node;
+    node->prev = new_node;
+    self->count += 1;
+    retval = (PyObject*)LinkedListIterObject_new(self, new_node);
+    return retval;
+}
+
+static PyObject* LinkedList_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+{
+    LinkedListObject *self;
+    LinkedListNode *sentinal;
+
+    self = (LinkedListObject *)type->tp_alloc(type, 0);
+    if (self == NULL) return NULL;
+
+    sentinal = make_new_node(NULL, NULL, NULL);
+    if(!sentinal) {
+        Py_DECREF(self);
+        return NULL;
+    }
+    self->sentinal = sentinal->next = sentinal->prev = sentinal;
+    sentinal->iter_count = 1; // prevent the sentinal from being deleted
+    self->count = 0;
+
+    return (PyObject *)self;
+}
+
+static void LinkedList_dealloc(LinkedListObject* self)
+{
+    LinkedListNode *node, *tmp;
+
+    node = self->sentinal->next;
+    while(node != self->sentinal) {
+        node->deleted = 1;
+        tmp = node->next;
+        check_node_deleted(node);
+        node = tmp;
+    }
+
+    self->sentinal->iter_count -= 1;
+    check_node_deleted(self->sentinal);
+    return;
+}
+
+static int LinkedList_init(LinkedListObject *self)
+{
+    self->count = 0;
+    return 0;
+}
+
+static Py_ssize_t LinkedList_len(LinkedListObject *self)
+{
+    return self->count;
+}
+
+static PyObject* LinkedList_get(LinkedListObject *self,
+        LinkedListIterObject *iter)
+{
+    if(!PyObject_TypeCheck(iter, &LinkedListIterType)) {
+        set_iter_type_error((PyObject*)iter);
+        return NULL;
+    }
+    return PyObject_CallMethod((PyObject*)iter, "value", "()");
+}
+int LinkedList_set(LinkedListObject *self, LinkedListIterObject *iter,
+        PyObject *value)
+{
+    if(!PyObject_TypeCheck(iter, &LinkedListIterType)) {
+        set_iter_type_error((PyObject*)iter);
+        return -1;
+    }
+    if(iter->node->deleted) {
+        PyErr_SetString(PyExc_ValueError, "Node deleted");
+        return -1;
+    }
+    if(iter->node->obj == NULL) {
+        PyErr_SetString(PyExc_IndexError, "can't set value of lastIter()");
+        return -1;
+    }
+    if(value == NULL) {
+        if(!remove_node(self, iter->node)) return -1;
+        return 0;
+    }
+    Py_INCREF(value);
+    Py_DECREF(iter->node->obj);
+    iter->node->obj = value;
+    return 0;
+}
+
+static PyObject *LinkedList_insertBefore(LinkedListObject* self, PyObject *args)
+{
+    LinkedListIterObject *iter;
+    PyObject *obj;
+
+    if(!PyArg_ParseTuple(args, "OO", &iter, &obj)) return NULL;
+    if(!PyObject_TypeCheck(iter, &LinkedListIterType)) {
+        set_iter_type_error(obj);
+        return NULL;
+    }
+
+    return insert_before(self, iter->node, obj);
+}
+
+static PyObject *LinkedList_append(LinkedListObject* self, PyObject *obj)
+{
+    return insert_before(self, self->sentinal, obj);
+}
+
+static PyObject *LinkedList_remove(LinkedListObject* self,
+        LinkedListIterObject *iter)
+{
+    LinkedListNode* next_node;
+    if(!PyObject_TypeCheck(iter, &LinkedListIterType)) {
+        set_iter_type_error((PyObject*)iter);
+        return NULL;
+    }
+
+    next_node = iter->node->next;
+    if(!remove_node(self, iter->node)) return NULL;
+    return (PyObject*)LinkedListIterObject_new(self, next_node);
+}
+
+static PyObject *LinkedList_firstIter(LinkedListObject* self, PyObject *obj)
+{
+    PyObject* retval;
+    retval = (PyObject*)LinkedListIterObject_new(self, self->sentinal->next);
+    return retval;
+}
+
+static PyObject *LinkedList_lastIter(LinkedListObject* self, PyObject *obj)
+{
+    PyObject* retval;
+    retval = (PyObject*)LinkedListIterObject_new(self, self->sentinal);
+    return retval;
+}
+
+static PyMappingMethods LinkedListMappingMethods = {
+    (lenfunc)LinkedList_len,
+    (binaryfunc)LinkedList_get,
+    (objobjargproc)LinkedList_set,
+};
+
+static PyMethodDef LinkedList_methods[] = {
+    {"insertBefore", (PyCFunction)LinkedList_insertBefore, METH_VARARGS,
+        "insert an element before iter",
+    },
+    {"append", (PyCFunction)LinkedList_append, METH_O,
+        "append an element to the list",
+    },
+    {"remove", (PyCFunction)LinkedList_remove, METH_O,
+        "remove an element to the list",
+    },
+    {"firstIter", (PyCFunction)LinkedList_firstIter, METH_NOARGS,
+        "get an iter pointing to the first element in the list",
+    },
+    {"lastIter", (PyCFunction)LinkedList_lastIter, METH_NOARGS,
+        "get an iter pointing to the last element in the list",
+    },
+    {NULL},
+};
+
+static PyTypeObject LinkedListType = {
+        PyObject_HEAD_INIT(NULL)
+            0,                                 /* ob_size */
+        "fasttypes.LinkedList",            /* tp_name */
+        sizeof(LinkedListObject),          /* tp_basicsize */
+        0,                                 /* tp_itemsize */
+        (destructor)LinkedList_dealloc,    /* tp_dealloc */
+        0,                                 /* tp_print */
+        0,                                 /* tp_getattr */
+        0,                                 /* tp_setattr */
+        0,                                 /* tp_compare */
+        0,                                 /* tp_repr */
+        0,                                 /* tp_as_number */
+        0,                                 /* tp_as_sequence */
+        &LinkedListMappingMethods,          /* tp_as_mapping */
+        0,                                 /* tp_hash  */
+        0,                                 /* tp_call */
+        0,                                 /* tp_str */
+        0,                                 /* tp_getattro */
+        0,                                 /* tp_setattro */
+        0,                                 /* tp_as_buffer */
+        Py_TPFLAGS_DEFAULT,                /* tp_flags */
+        "fasttypes LinkedList",            /* tp_doc */
+        0,                                 /* tp_traverse */
+        0,                                 /* tp_clear */
+        0,                                 /* tp_richcompare */
+        0,                                 /* tp_weaklistoffset */
+        0,                                 /* tp_iter */
+        0,                                 /* tp_iternext */
+        LinkedList_methods,               /* tp_methods */
+        0,                                 /* tp_members */
+        0,                                 /* tp_getset */
+        0,                                 /* tp_base */
+        0,                                 /* tp_dict */
+        0,                                 /* tp_descr_get */
+        0,                                 /* tp_descr_set */
+        0,                                 /* tp_dictoffset */
+        (initproc)LinkedList_init,         /* tp_init */
+        0,                                 /* tp_alloc */
+        LinkedList_new,           /* tp_new */
+};
+
+/* Module-level stuff */
+
+static PyObject *count_nodes_deleted(PyObject *obj)
+{
+    return PyInt_FromLong(nodes_deleted);
+}
+
+static PyObject *reset_nodes_deleted(PyObject *obj)
+{
+    nodes_deleted = 0;
+    Py_RETURN_NONE;
+}
+
+
+static PyMethodDef FasttypesMethods[] =
+{
+    {"_count_nodes_deleted", (PyCFunction)count_nodes_deleted, METH_NOARGS,
+        "get a count of how many nodes have been deleted (DEBUGGING ONLY)",
+    },
+    {"_reset_nodes_deleted", (PyCFunction)reset_nodes_deleted, METH_NOARGS,
+        "reset the count of how many nodes have been deleted (DEBUGGING ONLY)",
+    },
+    { NULL, NULL, 0, NULL }
+};
+
+PyMODINIT_FUNC initfasttypes(void)
+{
+    PyObject *m;
+
+    if (PyType_Ready(&LinkedListType) < 0)
+        return;
+
+    if (PyType_Ready(&LinkedListIterType) < 0)
+        return;
+
+    m = Py_InitModule("fasttypes", FasttypesMethods);
+
+    Py_INCREF(&LinkedListType);
+    Py_INCREF(&LinkedListIterType);
+    PyModule_AddObject(m, "LinkedList", (PyObject *)&LinkedListType);
+}
diff --git a/lvc/widgets/osx/helpers.py b/lvc/widgets/osx/helpers.py
new file mode 100644
index 0000000..e4aa23a
--- /dev/null
+++ b/lvc/widgets/osx/helpers.py
@@ -0,0 +1,95 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""helper classes."""
+
+import logging
+import traceback
+
+from Foundation import *
+from objc import nil
+
+class NotificationForwarder(NSObject):
+    """Forward notifications from a Cocoa object to a python class.
+    """
+
+    def initWithNSObject_center_(self, nsobject, center):
+        """Initialize the NotificationForwarder nsobject is the NSObject to
+        forward notifications for.  It can be nil in which case notifications
+        from all objects will be forwarded.
+
+        center is the NSNotificationCenter to get notifications from.  It can
+        be None, in which cas the default notification center is used.
+        """
+        self.nsobject = nsobject
+        self.callback_map = {}
+        if center is None:
+            self.center = NSNotificationCenter.defaultCenter()
+        else:
+            self.center = center
+        return self
+
+    @classmethod
+    def create(cls, object, center=None):
+        """Helper method to call aloc() then initWithNSObject_center_()."""
+        return cls.alloc().initWithNSObject_center_(object, center)
+
+    def connect(self, callback, name):
+        """Register to listen for notifications.
+        Only one callback for each notification name can be connected.
+        """
+
+        if name in self.callback_map:
+            raise ValueError("%s already connected" % name)
+
+        self.callback_map[name] = callback
+        self.center.addObserver_selector_name_object_(self, 'observe:', name,
+                self.nsobject)
+
+    def disconnect(self, name=None):
+        if name is not None:
+            self.center.removeObserver_name_object_(self, name, self.nsobject)
+            self.callback_map.pop(name)
+        else:
+            self.center.removeObserver_(self)
+            self.callback_map.clear()
+
+    def observe_(self, notification):
+        name = notification.name()
+        callback = self.callback_map[name]
+        if callback is None:
+            logging.warn("Callback for %s is dead", name)
+            self.center.removeObverser_name_object_(self, name, self.nsobject)
+            return
+        try:
+            callback(notification)
+        except:
+            logging.warn("Callback for %s raised exception:%s\n",
+                    name.encode('utf-8'),
+                    traceback.format_exc())
diff --git a/lvc/widgets/osx/layout.py b/lvc/widgets/osx/layout.py
new file mode 100644
index 0000000..f18a47f
--- /dev/null
+++ b/lvc/widgets/osx/layout.py
@@ -0,0 +1,748 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".layout -- Widgets that handle laying out other
+widgets.
+
+We basically follow GTK's packing model.  Widgets are packed into vboxes,
+hboxes or other container widgets.  The child widgets request a minimum size,
+and the container widgets allocate space for their children.  Widgets may get
+more size then they requested in which case they have to deal with it.  In
+rare cases, widgets may get less size then they requested in which case they
+should just make sure they don't throw an exception or segfault.
+
+Check out the GTK tutorial for more info.
+"""
+
+import itertools
+
+from AppKit import *
+from Foundation import *
+from objc import YES, NO, nil, signature, loadBundle
+
+import tableview
+import wrappermap
+from .base import Container, Bin, FlippedView
+from lvc.utils import Matrix
+
+# These don't seem to be in pyobjc's AppKit (yet)
+NSScrollerKnobStyleDefault = 0
+NSScrollerKnobStyleDark = 1
+NSScrollerKnobStyleLight = 2
+
+NSScrollerStyleLegacy = 0
+NSScrollerStyleOverlay = 1
+
+def _extra_space_iter(extra_length, count):
+    """Utility function to allocate extra space left over in containers."""
+    if count == 0:
+        return
+    extra_space, leftover = divmod(extra_length, count)
+    while leftover >= 1:
+        yield extra_space + 1
+        leftover -= 1
+    yield extra_space + leftover
+    while True:
+        yield extra_space
+
+class BoxPacking:
+    """Utility class to store how we are packing a single widget."""
+
+    def __init__(self, widget, expand, padding):
+        self.widget = widget
+        self.expand = expand
+        self.padding = padding
+
+class Box(Container):
+    """Base class for HBox and VBox.  """
+    CREATES_VIEW = False
+
+    def __init__(self, spacing=0):
+        self.spacing = spacing
+        Container.__init__(self)
+        self.packing_start = []
+        self.packing_end = []
+        self.expand_count = 0
+
+    def packing_both(self):
+        return itertools.chain(self.packing_start, self.packing_end)
+
+    def get_children(self):
+        for packing in self.packing_both():
+            yield packing.widget
+    children = property(get_children)
+
+    # Internally Boxes use a (length, breadth) coordinate system.  length and
+    # breadth will be either x or y depending on which way the box is
+    # oriented.  The subclasses must provide methods to translate between the
+    # 2 coordinate systems.
+
+    def translate_size(self, size):
+        """Translate a (width, height) tulple to (length, breadth)."""
+        raise NotImplementedError()
+
+    def untranslate_size(self, size):
+        """Reverse the work of translate_size."""
+        raise NotImplementedError()
+
+    def make_child_rect(self, position, length):
+        """Create a rect to position a child with."""
+        raise NotImplementedError()
+
+    def pack_start(self, child, expand=False, padding=0):
+        self.packing_start.append(BoxPacking(child, expand, padding))
+        if expand:
+            self.expand_count += 1
+        self.child_added(child)
+
+    def pack_end(self, child, expand=False, padding=0):
+        self.packing_end.append(BoxPacking(child, expand, padding))
+        if expand:
+            self.expand_count += 1
+        self.child_added(child)
+
+    def _remove_from_packing(self, child):
+        for i in xrange(len(self.packing_start)):
+            if self.packing_start[i].widget is child:
+                return self.packing_start.pop(i)
+        for i in xrange(len(self.packing_end)):
+            if self.packing_end[i].widget is child:
+                return self.packing_end.pop(i)
+        raise LookupError("%s not found" % child)
+
+    def remove(self, child):
+        packing = self._remove_from_packing(child)
+        if packing.expand:
+            self.expand_count -= 1
+        self.child_removed(child)
+
+    def translate_widget_size(self, widget):
+        return self.translate_size(widget.get_size_request())
+
+    def calc_size_request(self):
+        length = breadth = 0
+        for packing in self.packing_both():
+            child_length, child_breadth = \
+                    self.translate_widget_size(packing.widget)
+            length += child_length
+            if packing.padding:
+                length += packing.padding * 2 # Need to pad on both sides
+            breadth = max(breadth, child_breadth)
+        spaces = max(0, len(self.packing_start) + len(self.packing_end) - 1)
+        length += spaces * self.spacing
+        return self.untranslate_size((length, breadth))
+
+    def place_children(self):
+        request_length, request_breadth = self.translate_widget_size(self)
+        ps = self.viewport.placement.size
+        total_length, dummy = self.translate_size((ps.width, ps.height))
+        total_extra_space = total_length - request_length
+        extra_space_iter = _extra_space_iter(total_extra_space,
+                self.expand_count)
+        start_end = self._place_packing_list(self.packing_start,
+                extra_space_iter, 0)
+        if self.expand_count == 0 and total_extra_space > 0:
+            # account for empty space after the end of pack_start list and
+            # before the pack_end list.
+            self.draw_empty_space(start_end, total_extra_space)
+            start_end += total_extra_space
+        self._place_packing_list(reversed(self.packing_end), extra_space_iter,
+                start_end)
+
+    def draw_empty_space(self, start, length):
+        empty_rect = self.make_child_rect(start, length)
+        my_view = self.viewport.view
+        opaque_view = my_view.opaqueAncestor()
+        if opaque_view is not None:
+            empty_rect2 = opaque_view.convertRect_fromView_(empty_rect, my_view)
+            opaque_view.setNeedsDisplayInRect_(empty_rect2)
+
+    def _place_packing_list(self, packing_list, extra_space_iter, position):
+        for packing in packing_list:
+            child_length, child_breadth = \
+                    self.translate_widget_size(packing.widget)
+            if packing.expand:
+                child_length += extra_space_iter.next()
+            if packing.padding: # space before
+                self.draw_empty_space(position, packing.padding)
+                position += packing.padding
+            child_rect = self.make_child_rect(position, child_length)
+            if packing.padding: # space after
+                self.draw_empty_space(position, packing.padding)
+                position += packing.padding
+            packing.widget.place(child_rect, self.viewport.view)
+            position += child_length
+            if self.spacing > 0:
+                self.draw_empty_space(position, self.spacing)
+                position += self.spacing
+        return position
+
+    def enable(self):
+        Container.enable(self)
+        for mem in self.children:
+            mem.enable()
+
+    def disable(self):
+        Container.disable(self)
+        for mem in self.children:
+            mem.disable()
+
+class VBox(Box):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def translate_size(self, size):
+        return (size[1], size[0])
+
+    def untranslate_size(self, size):
+        return (size[1], size[0])
+
+    def make_child_rect(self, position, length):
+        placement = self.viewport.placement
+        return NSMakeRect(placement.origin.x, placement.origin.y + position,
+                placement.size.width, length)
+
+class HBox(Box):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def translate_size(self, size):
+        return (size[0], size[1])
+
+    def untranslate_size(self, size):
+        return (size[0], size[1])
+
+    def make_child_rect(self, position, length):
+        placement = self.viewport.placement
+        return NSMakeRect(placement.origin.x + position, placement.origin.y,
+                length, placement.size.height)
+
+class Alignment(Bin):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    CREATES_VIEW = False
+
+    def __init__(self, xalign=0.0, yalign=0.0, xscale=0.0, yscale=0.0,
+            top_pad=0, bottom_pad=0, left_pad=0, right_pad=0):
+        Bin.__init__(self)
+        self.xalign = xalign
+        self.yalign = yalign
+        self.xscale = xscale
+        self.yscale = yscale
+        self.top_pad = top_pad
+        self.bottom_pad = bottom_pad
+        self.left_pad = left_pad
+        self.right_pad = right_pad
+        if self.child is not None:
+            self.place_children()
+
+    def set(self, xalign=0.0, yalign=0.0, xscale=0.0, yscale=0.0):
+        self.xalign = xalign
+        self.yalign = yalign
+        self.xscale = xscale
+        self.yscale = yscale
+        if self.child is not None:
+            self.place_children()
+
+    def set_padding(self, top_pad=0, bottom_pad=0, left_pad=0, right_pad=0):
+        self.top_pad = top_pad
+        self.bottom_pad = bottom_pad
+        self.left_pad = left_pad
+        self.right_pad = right_pad
+        if self.child is not None and self.viewport is not None:
+            self.place_children()
+
+    def vertical_pad(self):
+        return self.top_pad + self.bottom_pad
+
+    def horizontal_pad(self):
+        return self.left_pad + self.right_pad
+
+    def calc_size_request(self):
+        if self.child:
+            child_width, child_height = self.child.get_size_request()
+            return (child_width + self.horizontal_pad(),
+                    child_height + self.vertical_pad())
+        else:
+            return (0, 0)
+
+    def calc_size(self, requested, total, scale):
+        extra_width = max(0, total - requested)
+        return requested + int(round(extra_width * scale))
+
+    def calc_position(self, size, total, align):
+        return int(round((total - size) * align))
+
+    def place_children(self):
+        if self.child is None:
+            return
+
+        total_width = self.viewport.placement.size.width
+        total_height = self.viewport.placement.size.height
+        total_width -= self.horizontal_pad()
+        total_height -= self.vertical_pad()
+        request_width, request_height = self.child.get_size_request()
+
+        child_width = self.calc_size(request_width, total_width, self.xscale)
+        child_height = self.calc_size(request_height, total_height, self.yscale)
+        child_x = self.calc_position(child_width, total_width, self.xalign)
+        child_y = self.calc_position(child_height, total_height, self.yalign)
+        child_x += self.left_pad
+        child_y += self.top_pad
+
+        my_origin = self.viewport.area().origin
+        child_rect = NSMakeRect(my_origin.x + child_x, my_origin.y + child_y,  child_width, child_height)
+        self.child.place(child_rect, self.viewport.view)
+        # Make sure the space not taken up by our child is redrawn.
+        self.viewport.queue_redraw()
+
+class DetachedWindowHolder(Alignment):
+    def __init__(self):
+        Alignment.__init__(self, bottom_pad=16, xscale=1.0, yscale=1.0)
+
+class _TablePacking(object):
+    """Utility class to help with packing Table widgets."""
+    def __init__(self, widget, column, row, column_span, row_span):
+        self.widget = widget
+        self.column = column
+        self.row = row
+        self.column_span = column_span
+        self.row_span = row_span
+
+    def column_indexes(self):
+        return range(self.column, self.column + self.column_span)
+
+    def row_indexes(self):
+        return range(self.row, self.row + self.row_span)
+
+class Table(Container):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    CREATES_VIEW = False
+
+    def __init__(self, columns, rows):
+        Container.__init__(self)
+        self._cells = Matrix(columns, rows)
+        self._children = [] # List of _TablePacking objects
+        self._children_sorted = True
+        self.rows = rows
+        self.columns = columns
+        self.row_spacing = self.column_spacing = 0
+
+    def _ensure_children_sorted(self):
+        if not self._children_sorted:
+            def cell_area(table_packing):
+                return table_packing.column_span * table_packing.row_span
+            self._children.sort(key=cell_area)
+            self._children_sorted = True
+
+    def get_children(self):
+        return [cell.widget for cell in self._children]
+    children = property(get_children)
+
+    def calc_size_request(self):
+        self._ensure_children_sorted()
+        self._calc_dimensions()
+        return self.total_width, self.total_height
+
+    def _calc_dimensions(self):
+        self.column_widths = [0] * self.columns
+        self.row_heights = [0] * self.rows
+
+        for tp in self._children:
+            child_width, child_height = tp.widget.get_size_request()
+            # recalc the width of the child's columns
+            self._recalc_dimension(child_width, self.column_widths,
+                    tp.column_indexes())
+            # recalc the height of the child's rows
+            self._recalc_dimension(child_height, self.row_heights,
+                    tp.row_indexes())
+
+        self.total_width = (self.column_spacing * (self.columns - 1) +
+                sum(self.column_widths))
+        self.total_height = (self.row_spacing * (self.rows - 1) +
+                sum(self.row_heights))
+
+    def _recalc_dimension(self, child_size, size_array, positions):
+        current_size = sum(size_array[p] for p in positions)
+        child_size_needed = child_size - current_size
+        if child_size_needed > 0:
+            iter = _extra_space_iter(child_size_needed, len(positions))
+            for p in positions:
+                size_array[p] += iter.next()
+
+    def place_children(self):
+        # This method depepnds on us calling _calc_dimensions() in
+        # calc_size_request().  Ensure that this happens.
+        if self.cached_size_request is None:
+            self.get_size_request()
+        column_positions = [0]
+        for width in self.column_widths[:-1]:
+            column_positions.append(width + column_positions[-1] + self.column_spacing)
+        row_positions = [0]
+        for height in self.row_heights[:-1]:
+            row_positions.append(height + row_positions[-1] + self.row_spacing)
+
+        my_x= self.viewport.placement.origin.x
+        my_y = self.viewport.placement.origin.y
+        for tp in self._children:
+            x = my_x + column_positions[tp.column]
+            y = my_y + row_positions[tp.row]
+            width = sum(self.column_widths[i] for i in tp.column_indexes())
+            height = sum(self.row_heights[i] for i in tp.row_indexes())
+            rect = NSMakeRect(x, y, width, height)
+            tp.widget.place(rect, self.viewport.view)
+
+    def pack(self, widget, column, row, column_span=1, row_span=1):
+        tp = _TablePacking(widget, column, row, column_span, row_span)
+        for c in tp.column_indexes():
+            for r in tp.row_indexes():
+                if self._cells[c, r]:
+                    raise ValueError("Cell %d x %d is already taken" % (c, r))
+        self._cells[column, row] = widget
+        self._children.append(tp)
+        self._children_sorted = False
+        self.child_added(widget)
+
+    def remove(self, child):
+        for i in xrange(len(self._children)):
+            if self._children[i].widget is child:
+                self._children.remove(i)
+                break
+        else:
+            raise ValueError("%s is not a child of this Table" % child)
+        self._cells.remove(child)
+        self.child_removed(widget)
+
+    def set_column_spacing(self, spacing):
+        self.column_spacing = spacing
+        self.invalidate_size_request()
+
+    def set_row_spacing(self, spacing):
+        self.row_spacing = spacing
+        self.invalidate_size_request()
+
+    def enable(self, row=None, column=None):
+        Container.enable(self)
+        if row != None and column != None:
+            if self._cells[column, row]:
+                self._cells[column, row].enable()
+        elif row != None:
+            for mem in self._cells.row(row):
+                if mem: mem.enable()
+        elif column != None:
+            for mem in self._cells.column(column):
+                if mem: mem.enable()
+        else:
+            for mem in self._cells:
+                if mem: mem.enable()
+
+    def disable(self, row=None, column=None):
+        Container.disable(self)
+        if row != None and column != None:
+            if self._cells[column, row]:
+                self._cells[column, row].disable()
+        elif row != None:
+            for mem in self._cells.row(row):
+                if mem: mem.disable()
+        elif column != None:
+            for mem in self._cells.column(column):
+                if mem: mem.disable()
+        else:
+            for mem in self._cells:
+                if mem: mem.disable()
+
+class MiroScrollView(NSScrollView):
+    def tile(self):
+        NSScrollView.tile(self)
+        # tile is called when we need to layout our child view and scrollers.
+        # This probably means that we've either hidden or shown a scrollbar so
+        # call invalidate_size_request to ensure that things get re-layed out
+        # correctly.  (#see 13842)
+        wrapper = wrappermap.wrapper(self)
+        if wrapper is not None:
+            wrapper.invalidate_size_request()
+
+class Scroller(Bin):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self, horizontal, vertical):
+        Bin.__init__(self)
+        self.view = MiroScrollView.alloc().init()
+        self.view.setAutohidesScrollers_(YES)
+        self.view.setHasHorizontalScroller_(horizontal)
+        self.view.setHasVerticalScroller_(vertical)
+        self.document_view = FlippedView.alloc().init()
+        self.view.setDocumentView_(self.document_view)
+
+    def prepare_for_dark_content(self):
+        try:
+            self.view.setScrollerKnobStyle_(NSScrollerKnobStyleLight)
+        except AttributeError:
+            # This only works on 10.7 and abvoe
+            pass
+
+    def set_has_borders(self, has_border):
+        self.view.setBorderType_(NSBezelBorder)
+
+    def viewport_repositioned(self):
+        # If the window is resized, this translates to a
+        # viewport_repositioned() event.  Instead of calling
+        # place_children() one, which is what our suporclass does, we need
+        # some extra logic here.  place the chilren to work out if we need a
+        # scrollbar, then get the new size, then replace the children (which
+        # now takes into account of scrollbar size.)
+        super(Scroller, self).viewport_repositioned()
+        self.cached_size_request = self.calc_size_request()
+        self.place_children()
+
+    def set_background_color(self, color):
+        self.view.setBackgroundColor_(self.make_color(color))
+
+    def add(self, child):
+        child.parent_is_scroller = True
+        Bin.add(self, child)
+
+    def remove(self):
+        child.parent_is_scroller = False
+        Bin.remove(self)
+
+    def children_changed(self):
+        # since our size isn't dependent on our children, don't call
+        # invalidate_size_request() here.  Just call place_children() so that
+        # they get positioned correctly in the document view.
+        #
+        # XXX dodgy - why are we laying out the children twice?  When the
+        # children change, the scroller could appear/disappear.  But you have
+        # no idea if that's going to happen without knowing how big your
+        # children are.  So we lay it out, get the size, then, place the
+        # children again.  This makes sure that the right side of the children
+        # are redrawn.  There's got to be a better way??
+        self.place_children()
+        self.cached_size_request = self.calc_size_request()
+        self.place_children()
+
+    def calc_size_request(self):
+        if self.child:
+            width = height = 0
+            try:
+                legacy = self.view.scrollerStyle() == NSScrollerStyleLegacy
+            except AttributeError:
+                legacy = True
+            if not self.view.hasHorizontalScroller():
+                width = self.child.get_size_request()[0]
+            if not self.view.hasVerticalScroller():
+                height = self.child.get_size_request()[1]
+            # Add a little room for the scrollbars (if necessary)
+            if legacy and self.view.hasHorizontalScroller():
+                height += NSScroller.scrollerWidth()
+            if legacy and self.view.hasVerticalScroller():
+                width += NSScroller.scrollerWidth()
+            return width, height
+        else:
+            return 0, 0
+
+    def place_children(self):
+        if self.child is not None:
+            scroll_view_size = self.view.contentView().frame().size
+            child_width, child_height = self.child.get_size_request()
+            child_width = max(child_width, scroll_view_size.width)
+            child_height = max(child_height, scroll_view_size.height)
+            frame = NSRect(NSPoint(0,0), NSSize(child_width, child_height))
+            if isinstance(self.child, tableview.TableView) and self.child.is_showing_headers():
+                # Hack to allow the content of a table view to scroll, but not
+                # the headers
+                self.child.place(frame, self.document_view)
+                if self.view.documentView() is not self.child.tableview:
+                    self.view.setDocumentView_(self.child.tableview)
+            else:
+                self.child.place(frame, self.document_view)
+            self.document_view.setFrame_(frame)
+            self.document_view.setNeedsDisplay_(YES)
+        self.view.setNeedsDisplay_(YES)
+        self.child.emit('place-in-scroller')
+
+class ExpanderView(FlippedView):
+    def init(self):
+        self = super(ExpanderView, self).init()
+        self.label_rect = None
+        self.content_view = None
+        self.button = NSButton.alloc().init()
+        self.button.setState_(NSOffState)
+        self.button.setTitle_("")
+        self.button.setBezelStyle_(NSDisclosureBezelStyle)
+        self.button.setButtonType_(NSPushOnPushOffButton)
+        self.button.sizeToFit()
+        self.addSubview_(self.button)
+        self.button.setTarget_(self)
+        self.button.setAction_('buttonChanged:')
+        self.content_view = FlippedView.alloc().init()
+        return self
+
+    def buttonChanged_(self, button):
+        if button.state() == NSOnState:
+            self.addSubview_(self.content_view)
+        else:
+            self.content_view.removeFromSuperview()
+        if self.window():
+            wrappermap.wrapper(self).invalidate_size_request()
+
+    def mouseDown_(self, event):
+        pass  # Just need to respond to the selector so we get mouseUp_
+
+    def mouseUp_(self, event):
+        position = event.locationInWindow()
+        window_label_rect = self.convertRect_toView_(self.label_rect, None)
+        if NSPointInRect(position, window_label_rect):
+            self.button.setNextState()
+            self.buttonChanged_(self.button)
+
+class Expander(Bin):
+    BUTTON_PAD_TOP = 2
+    BUTTON_PAD_LEFT = 4
+    LABEL_SPACING = 4
+
+    def __init__(self, child):
+        Bin.__init__(self)
+        if child:
+            self.add(child)
+        self.label = None
+        self.spacing = 0
+        self.view = ExpanderView.alloc().init()
+        self.button = self.view.button
+        self.button.setFrameOrigin_(NSPoint(self.BUTTON_PAD_LEFT,
+            self.BUTTON_PAD_TOP))
+        self.content_view = self.view.content_view
+
+    def remove_viewport(self):
+        Bin.remove_viewport(self)
+        if self.label is not None:
+            self.label.remove_viewport()
+
+    def set_spacing(self, spacing):
+        self.spacing = spacing
+
+    def set_label(self, widget):
+        if self.label is not None:
+            self.label.remove_viewport()
+        self.label = widget
+        self.children_changed()
+
+    def set_expanded(self, expanded):
+        if expanded:
+            self.button.setState_(NSOnState)
+        else:
+            self.button.setState_(NSOffState)
+        self.view.buttonChanged_(self.button)
+
+    def calc_top_size(self):
+        width = self.button.bounds().size.width
+        height = self.button.bounds().size.height
+        if self.label is not None:
+            label_width, label_height = self.label.get_size_request()
+            width += self.LABEL_SPACING + label_width
+            height = max(height, label_height)
+        width += self.BUTTON_PAD_LEFT
+        height += self.BUTTON_PAD_TOP
+        return width, height
+
+    def calc_size_request(self):
+        width, height = self.calc_top_size()
+        if self.child is not None and self.button.state() == NSOnState:
+            child_width, child_height = self.child.get_size_request()
+            width = max(width, child_width)
+            height += self.spacing + child_height
+        return width, height
+
+    def place_children(self):
+        top_width, top_height = self.calc_top_size()
+        if self.label:
+            label_width, label_height = self.label.get_size_request()
+            button_width = self.button.bounds().size.width
+            label_x = self.BUTTON_PAD_LEFT + button_width + self.LABEL_SPACING
+            label_rect = NSMakeRect(label_x, self.BUTTON_PAD_TOP,
+                    label_width, label_height)
+            self.label.place(label_rect, self.viewport.view)
+            self.view.label_rect = label_rect
+        if self.child:
+            size = self.viewport.area().size
+            child_rect = NSMakeRect(0, 0, size.width, size.height -
+                    top_height)
+            self.content_view.setFrame_(NSMakeRect(0, top_height, size.width,
+                size.height - top_height))
+            self.child.place(child_rect, self.content_view)
+
+
+class TabViewDelegate(NSObject):
+    def tabView_willSelectTabViewItem_(self, tab_view, tab_view_item):
+        try:
+            wrapper = wrappermap.wrapper(tab_view)
+        except KeyError:
+            pass # The NSTabView hasn't been placed yet, don't worry about it.
+        else:
+            wrapper.place_child_with_item(tab_view_item)
+
+class TabContainer(Container):
+    def __init__(self):
+        Container.__init__(self)
+        self.children = []
+        self.item_to_child = {}
+        self.view = NSTabView.alloc().init()
+        self.view.setAllowsTruncatedLabels_(NO)
+        self.delegate = TabViewDelegate.alloc().init()
+        self.view.setDelegate_(self.delegate)
+
+    def append_tab(self, child_widget, label, image):
+        item = NSTabViewItem.alloc().init()
+        item.setLabel_(label)
+        item.setView_(FlippedView.alloc().init())
+        self.view.addTabViewItem_(item)
+        self.children.append(child_widget)
+        self.child_added(child_widget)
+        self.item_to_child[item] = child_widget
+
+    def select_tab(self, index):
+        self.view.selectTabViewItemAtIndex_(index)
+
+    def place_children(self):
+        self.place_child_with_item(self.view.selectedTabViewItem())
+
+    def place_child_with_item(self, tab_view_item):
+        child = self.item_to_child[tab_view_item]
+        child_view = tab_view_item.view()
+        content_rect =self.view.contentRect()
+        child_view.setFrame_(content_rect)
+        child.place(child_view.bounds(), child_view)
+
+    def calc_size_request(self):
+        tab_size = self.view.minimumSize()
+        # make sure there's enough room for the tabs, plus a little extra
+        # space to make things look good
+        max_width = tab_size.width + 60
+        max_height = 0
+        for child in self.children:
+            width, height = child.get_size_request()
+            max_width = max(width, max_width)
+            max_height = max(height, max_height)
+        max_height += tab_size.height
+
+        return max_width, max_height
diff --git a/lvc/widgets/osx/layoutmanager.py b/lvc/widgets/osx/layoutmanager.py
new file mode 100644
index 0000000..de4301b
--- /dev/null
+++ b/lvc/widgets/osx/layoutmanager.py
@@ -0,0 +1,445 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""textlayout.py -- Contains the LayoutManager class.  It handles laying text,
+buttons, getting font metrics and other tasks that are required to size
+things.
+"""
+import logging
+import math
+
+from AppKit import *
+from Foundation import *
+from objc import YES, NO, nil
+
+import drawing
+
+INFINITE = 1000000 # size of an "infinite" dimension
+
+class MiroLayoutManager(NSLayoutManager):
+    """Overide NSLayoutManager to draw better underlines."""
+
+    def drawUnderlineForGlyphRange_underlineType_baselineOffset_lineFragmentRect_lineFragmentGlyphRange_containerOrigin_(self, glyph_range, typ, offset, line_rect, line_glyph_range, container_origin):
+        container, _ = self.textContainerForGlyphAtIndex_effectiveRange_(glyph_range.location, None)
+        rect = self.boundingRectForGlyphRange_inTextContainer_(glyph_range, container)
+        x = container_origin.x + rect.origin.x
+        y = (container_origin.y + rect.origin.y + rect.size.height - offset)
+        underline_height, offset = self.calc_underline_extents(glyph_range)
+        y = math.ceil(y + offset) + underline_height / 2.0
+        path = NSBezierPath.bezierPath()
+        path.setLineWidth_(underline_height)
+        path.moveToPoint_(NSPoint(x, y))
+        path.relativeLineToPoint_(NSPoint(rect.size.width, 0))
+        path.stroke()
+
+    def calc_underline_extents(self, line_glyph_range):
+        index = self.characterIndexForGlyphAtIndex_(line_glyph_range.location)
+        font, _ = self.textStorage().attribute_atIndex_effectiveRange_(NSFontAttributeName, index, None)
+        # we use a couple of magic numbers that seems to work okay.  I (BDK)
+        # got it from some old mozilla code.
+        height = font.ascender() - font.descender()
+        height = max(1.0, round(0.05 * height))
+        offset = max(1.0, round(0.1 * height))
+        return height, offset
+
+class TextBoxPool(object):
+    """Handles a pool of TextBox objects.  We monitor the TextBox objects and
+    when those objects die, we reclaim them for the pool.
+
+    Creating TextBoxes is fairly expensive and NSLayoutManager do a lot of
+    caching, so it's useful to keep them around rather than destroying them.
+    """
+
+    def __init__(self):
+        self.used_text_boxes = []
+        self.available_text_boxes = []
+
+    def get(self):
+        """Get a NSLayoutManager, either from the pool or by creating a new
+        one.
+        """
+        try:
+            rv = self.available_text_boxes.pop()
+        except IndexError:
+            rv = TextBox()
+        self.used_text_boxes.append(rv)
+        return rv
+
+    def reclaim_textboxes(self):
+        """Move used TextBoxes back to the available pool.  This should be
+        called after the code using text boxes is done using all of them.
+        """
+        self.available_text_boxes.extend(self.used_text_boxes)
+        self.used_text_boxes[:] = []
+
+text_box_pool = TextBoxPool()
+
+class Font(object):
+    line_height_sizer = NSLayoutManager.alloc().init()
+
+    def __init__(self, nsfont):
+        self.nsfont = nsfont
+
+    def ascent(self):
+        return self.nsfont.ascender()
+
+    def descent(self):
+        return -self.nsfont.descender()
+
+    def line_height(self):
+        return Font.line_height_sizer.defaultLineHeightForFont_(self.nsfont)
+
+class FontPool(object):
+    def __init__(self):
+        self._cached_fonts = {}
+
+    def get(self, scale_factor, bold, italic, family):
+        cache_key = (scale_factor, bold, italic, family)
+        try:
+            return self._cached_fonts[cache_key]
+        except KeyError:
+            font = self._create(scale_factor, bold, italic, family)
+            self._cached_fonts[cache_key] = font
+            return font
+
+    def _create(self, scale_factor, bold, italic, family):
+        size = round(scale_factor * NSFont.systemFontSize())
+        nsfont = None
+        if family is not None:
+            if bold:
+                nsfont = NSFont.fontWithName_size_(family + " Bold", size)
+            else:
+                nsfont = NSFont.fontWithName_size_(family, size)
+            if nsfont is None:
+                logging.error('FontPool: family %s scale %s bold %s '
+                              'italic %s not found',
+                              family, scale_factor, bold, italic)
+        # Att his point either we have requested a custom font that failed
+        # to load or the system font was requested.
+        if nsfont is None:
+            if bold:
+                nsfont = NSFont.boldSystemFontOfSize_(size)
+            else:
+                nsfont = NSFont.systemFontOfSize_(size)
+        return Font(nsfont)
+
+class LayoutManager(object):
+    font_pool = FontPool()
+    default_font = font_pool.get(1.0, False, False, None)
+
+    def __init__(self):
+        self.current_font = self.default_font
+        self.set_text_color((0, 0, 0))
+        self.set_text_shadow(None)
+
+    def font(self, scale_factor, bold=False, italic=False, family=None):
+        return self.font_pool.get(scale_factor, bold, italic, family)
+
+    def set_font(self, scale_factor, bold=False, italic=False, family=None):
+        self.current_font = self.font(scale_factor, bold, italic, family)
+
+    def set_text_color(self, color):
+        self.text_color = color
+
+    def set_text_shadow(self, shadow):
+        self.shadow = shadow
+
+    def textbox(self, text, underline=False):
+        text_box = text_box_pool.get()
+        color = NSColor.colorWithDeviceRed_green_blue_alpha_(self.text_color[0], self.text_color[1], self.text_color[2], 1.0)
+        text_box.reset(text, self.current_font, color, self.shadow, underline)
+        return text_box
+
+    def button(self, text, pressed=False, disabled=False, style='normal'):
+        if style == 'webby':
+            return StyledButton(text, self.current_font, pressed, disabled)
+        else:
+            return NativeButton(text, self.current_font, pressed, disabled)
+
+    def reset(self):
+        text_box_pool.reclaim_textboxes()
+        self.current_font = self.default_font
+        self.text_color = (0, 0, 0)
+        self.shadow = None
+
+class TextBox(object):
+    def __init__(self):
+        self.layout_manager = MiroLayoutManager.alloc().init()
+        container = NSTextContainer.alloc().init()
+        container.setLineFragmentPadding_(0)
+        self.layout_manager.addTextContainer_(container)
+        self.layout_manager.setUsesFontLeading_(NO)
+        self.text_storage = NSTextStorage.alloc().init()
+        self.text_storage.addLayoutManager_(self.layout_manager)
+        self.text_container = self.layout_manager.textContainers()[0]
+
+    def reset(self, text, font, color, shadow, underline):
+        """Reset the text box so it's ready to be used by a new owner."""
+        self.text_storage.deleteCharactersInRange_(NSRange(0,
+            self.text_storage.length()))
+        self.text_container.setContainerSize_(NSSize(INFINITE, INFINITE))
+        self.paragraph_style = NSMutableParagraphStyle.alloc().init()
+        self.font = font
+        self.color = color
+        self.shadow = shadow
+        self.width = None
+        self.set_text(text, underline=underline)
+
+    def make_attr_string(self, text, color, font, underline):
+        attributes = NSMutableDictionary.alloc().init()
+        if color is not None:
+            nscolor = NSColor.colorWithDeviceRed_green_blue_alpha_(color[0], color[1], color[2], 1.0)
+            attributes.setObject_forKey_(nscolor, NSForegroundColorAttributeName)
+        else:
+            attributes.setObject_forKey_(self.color, NSForegroundColorAttributeName)
+        if font is not None:
+            attributes.setObject_forKey_(font.nsfont, NSFontAttributeName)
+        else:
+            attributes.setObject_forKey_(self.font.nsfont, NSFontAttributeName)
+        if underline:
+            attributes.setObject_forKey_(NSUnderlineStyleSingle, NSUnderlineStyleAttributeName)
+        attributes.setObject_forKey_(self.paragraph_style.copy(), NSParagraphStyleAttributeName)
+        if text is None:
+            text = ""
+        return NSAttributedString.alloc().initWithString_attributes_(text, attributes)
+
+    def set_text(self, text, color=None, font=None, underline=False):
+        string = self.make_attr_string(text, color, font, underline)
+        self.text_storage.setAttributedString_(string)
+
+    def append_text(self, text, color=None, font=None, underline=False):
+        string = self.make_attr_string(text, color, font, underline)
+        self.text_storage.appendAttributedString_(string)
+
+    def set_width(self, width):
+        if width is not None:
+            self.text_container.setContainerSize_(NSSize(width, INFINITE))
+        else:
+            self.text_container.setContainerSize_(NSSize(INFINITE, INFINITE))
+        self.width = width
+
+    def update_paragraph_style(self):
+        attr = NSParagraphStyleAttributeName
+        value = self.paragraph_style.copy()
+        rnge = NSMakeRange(0, self.text_storage.length())
+        self.text_storage.addAttribute_value_range_(attr, value, rnge)
+
+    def set_wrap_style(self, wrap):
+        if wrap == 'word':
+            self.paragraph_style.setLineBreakMode_(NSLineBreakByWordWrapping)
+        elif wrap == 'char':
+            self.paragraph_style.setLineBreakMode_(NSLineBreakByCharWrapping)
+        elif wrap == 'truncated-char':
+            self.paragraph_style.setLineBreakMode_(NSLineBreakByTruncatingTail)
+        else:
+            raise ValueError("Unknown wrap value: %s" % wrap)
+        self.update_paragraph_style()
+
+    def set_alignment(self, align):
+        if align == 'left':
+            self.paragraph_style.setAlignment_(NSLeftTextAlignment)
+        elif align == 'right':
+            self.paragraph_style.setAlignment_(NSRightTextAlignment)
+        elif align == 'center':
+            self.paragraph_style.setAlignment_(NSCenterTextAlignment)
+        else:
+            raise ValueError("Unknown align value: %s" % align)
+        self.update_paragraph_style()
+
+    def get_size(self):
+        # The next line is there just to force cocoa to layout the text
+        self.layout_manager.glyphRangeForTextContainer_(self.text_container)
+        rect = self.layout_manager.usedRectForTextContainer_(self.text_container)
+        return rect.size.width, rect.size.height
+
+    def char_at(self, x, y):
+        width, height = self.get_size()
+        if 0 <= x < width and 0 <= y < height:
+            index, _ = self.layout_manager.glyphIndexForPoint_inTextContainer_fractionOfDistanceThroughGlyph_(NSPoint(x, y), self.text_container, None)
+            return index
+        else:
+            return None
+
+    def draw(self, context, x, y, width, height):
+        if self.shadow is not None:
+            context.save()
+            context.set_shadow(self.shadow.color, self.shadow.opacity, self.shadow.offset, self.shadow.blur_radius)
+        self.width = width
+        self.text_container.setContainerSize_(NSSize(width, height))
+        glyph_range = self.layout_manager.glyphRangeForTextContainer_(self.text_container)
+        self.layout_manager.drawGlyphsForGlyphRange_atPoint_(glyph_range, NSPoint(x, y))
+        if self.shadow is not None:
+            context.restore()
+        context.path.removeAllPoints()
+
+class NativeButton(object):
+
+    def __init__(self, text, font, pressed, disabled=False):
+        self.min_width = 0
+        self.cell = NSButtonCell.alloc().init()
+        self.cell.setBezelStyle_(NSRoundRectBezelStyle)
+        self.cell.setButtonType_(NSMomentaryPushInButton)
+        self.cell.setFont_(font.nsfont)
+        self.cell.setEnabled_(not disabled)
+        self.cell.setTitle_(text)
+        if pressed:
+            self.cell.setState_(NSOnState)
+        else:
+            self.cell.setState_(NSOffState)
+        self.cell.setImagePosition_(NSImageLeft)
+
+    def set_icon(self, icon):
+        image = icon.image.copy()
+        image.setFlipped_(NO)
+        self.cell.setImage_(image)
+
+    def get_size(self):
+        size = self.cell.cellSize()
+        return size.width, size.height
+
+    def draw(self, context, x, y, width, height):
+        rect = NSMakeRect(x, y, width, height)
+        NSGraphicsContext.currentContext().saveGraphicsState()
+        self.cell.drawWithFrame_inView_(rect, context.view)
+        NSGraphicsContext.currentContext().restoreGraphicsState()
+        context.path.removeAllPoints()
+
+class StyledButton(object):
+    PAD_HORIZONTAL = 11
+    BIG_PAD_VERTICAL = 4
+    SMALL_PAD_VERTICAL = 2
+    TOP_COLOR = (1, 1, 1)
+    BOTTOM_COLOR = (0.86, 0.86, 0.86)
+    LINE_COLOR_TOP = (0.71, 0.71, 0.71)
+    LINE_COLOR_BOTTOM = (0.45, 0.45, 0.45)
+    TEXT_COLOR = (0.19, 0.19, 0.19)
+    DISABLED_COLOR = (0.86, 0.86, 0.86)
+    DISABLED_TEXT_COLOR = (0.43, 0.43, 0.43)
+    ICON_PAD = 8
+
+    def __init__(self, text, font, pressed, disabled=False):
+        self.pressed = pressed
+        self.disabled = disabled
+        attributes = NSMutableDictionary.alloc().init()
+        attributes.setObject_forKey_(font.nsfont, NSFontAttributeName)
+        if self.disabled:
+            color = self.DISABLED_TEXT_COLOR
+        else:
+            color = self.TEXT_COLOR
+        nscolor = NSColor.colorWithDeviceRed_green_blue_alpha_(color[0], color[1], color[2], 1.0)
+        attributes.setObject_forKey_(nscolor, NSForegroundColorAttributeName)
+        self.title = NSAttributedString.alloc().initWithString_attributes_(text, attributes)
+        self.image = None
+
+    def set_icon(self, icon):
+        self.image = icon.image.copy()
+        self.image.setFlipped_(YES)
+
+    def get_size(self):
+        width, height = self.get_text_size()
+        if self.image is not None:
+            width += self.image.size().width + self.ICON_PAD
+            height = max(height, self.image.size().height)
+            height += self.BIG_PAD_VERTICAL * 2
+        else:
+            height += self.SMALL_PAD_VERTICAL * 2
+        if height % 2 == 1:
+            # make height even so that the radius of our circle is whole
+            height += 1
+        width += self.PAD_HORIZONTAL * 2
+        return width, height
+
+    def get_text_size(self):
+        size = self.title.size()
+        return size.width, size.height
+
+    def draw(self, context, x, y, width, height):
+        self._draw_button(context, x, y, width, height)
+        self._draw_title(context, x, y)
+        context.path.removeAllPoints()
+
+    def _draw_button(self, context, x, y, width, height):
+        radius = height / 2
+        self._draw_path(context, x, y, width, height, radius)
+        if self.disabled:
+            end_color = self.DISABLED_COLOR
+            start_color = self.DISABLED_COLOR
+        elif self.pressed:
+            end_color = self.TOP_COLOR
+            start_color = self.BOTTOM_COLOR
+        else:
+            context.set_line_width(1)
+            start_color = self.TOP_COLOR
+            end_color = self.BOTTOM_COLOR
+        gradient = drawing.Gradient(x, y, x, y+height)
+        gradient.set_start_color(start_color)
+        gradient.set_end_color(end_color)
+        context.gradient_fill(gradient)
+        self._draw_border(context, x, y, width, height, radius)
+
+    def _draw_path(self, context, x, y, width, height, radius):
+        inner_width = width - radius * 2
+        context.move_to(x + radius, y)
+        context.rel_line_to(inner_width, 0)
+        context.arc(x + width - radius, y+radius, radius, -math.pi/2, math.pi/2)
+        context.rel_line_to(-inner_width, 0)
+        context.arc(x + radius, y+radius, radius, math.pi/2, -math.pi/2)
+
+    def _draw_path_reverse(self, context, x, y, width, height, radius):
+        inner_width = width - radius * 2
+        context.move_to(x + radius, y)
+        context.arc_negative(x + radius, y+radius, radius, -math.pi/2, math.pi/2)
+        context.rel_line_to(inner_width, 0)
+        context.arc_negative(x + width - radius, y+radius, radius, math.pi/2, -math.pi/2)
+        context.rel_line_to(-inner_width, 0)
+
+    def _draw_border(self, context, x, y, width, height, radius):
+        self._draw_path(context, x, y, width, height, radius)
+        self._draw_path_reverse(context, x+1, y+1, width-2, height-2, radius-1)
+        gradient = drawing.Gradient(x, y, x, y+height)
+        gradient.set_start_color(self.LINE_COLOR_TOP)
+        gradient.set_end_color(self.LINE_COLOR_BOTTOM)
+        context.save()
+        context.clip()
+        context.rectangle(x, y, width, height)
+        context.gradient_fill(gradient)
+        context.restore()
+
+    def _draw_title(self, context, x, y):
+        c_width, c_height = self.get_size()
+        t_width, t_height = self.get_text_size()
+        x = x + self.PAD_HORIZONTAL
+        y = y + (c_height - t_height) / 2
+        if self.image is not None:
+            self.image.drawAtPoint_fromRect_operation_fraction_(
+                NSPoint(x, y+3), NSZeroRect, NSCompositeSourceOver, 1.0)
+            x += self.image.size().width + self.ICON_PAD
+        else:
+            y += 0.5
+        self.title.drawAtPoint_(NSPoint(x, y))
diff --git a/lvc/widgets/osx/osxmenus.py b/lvc/widgets/osx/osxmenus.py
new file mode 100644
index 0000000..91baf3a
--- /dev/null
+++ b/lvc/widgets/osx/osxmenus.py
@@ -0,0 +1,571 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""menus.py -- Menu handling code."""
+
+import logging
+import struct
+
+from objc import nil, NO, YES
+import AppKit
+from AppKit import *
+from Foundation import *
+
+from lvc import signals
+from lvc.widgets import keyboard
+# import these names directly into our namespace for easy access
+from lvc.widgets.keyboard import Shortcut, MOD
+
+# XXX hacks
+def _(text, *params):
+    if params:
+        return text % params[0]
+    return text
+
+MODIFIERS_MAP = {
+    keyboard.MOD:   NSCommandKeyMask,
+    keyboard.CMD:   NSCommandKeyMask,
+    keyboard.SHIFT: NSShiftKeyMask,
+    keyboard.CTRL:  NSControlKeyMask,
+    keyboard.ALT:   NSAlternateKeyMask
+}
+
+if isinstance(NSBackspaceCharacter, int):
+    backspace = NSBackspaceCharacter
+else:
+    backspace = ord(NSBackspaceCharacter)
+
+KEYS_MAP = {
+    keyboard.SPACE: " ",
+    keyboard.ENTER: "\r",
+    keyboard.BKSPACE: struct.pack("H", backspace),
+    keyboard.DELETE: NSDeleteFunctionKey,
+    keyboard.RIGHT_ARROW: NSRightArrowFunctionKey,
+    keyboard.LEFT_ARROW: NSLeftArrowFunctionKey,
+    keyboard.UP_ARROW: NSUpArrowFunctionKey,
+    keyboard.DOWN_ARROW: NSDownArrowFunctionKey,
+    '.': '.',
+    ',': ','
+}
+# add function keys
+for i in range(1, 13):
+    portable_key = getattr(keyboard, "F%s" % i)
+    osx_key = getattr(AppKit, "NSF%sFunctionKey" % i)
+    KEYS_MAP[portable_key] = osx_key
+
+REVERSE_MODIFIERS_MAP = dict((i[1], i[0]) for i in MODIFIERS_MAP.items())
+REVERSE_KEYS_MAP = dict((i[1], i[0]) for i in KEYS_MAP.items()
+        if i[0] != keyboard.BKSPACE)
+REVERSE_KEYS_MAP[u'\x7f'] = keyboard.BKSPACE
+REVERSE_KEYS_MAP[u'\x1b'] = keyboard.ESCAPE
+
+def make_modifier_mask(shortcut):
+    mask = 0
+    for modifier in shortcut.modifiers:
+        mask |= MODIFIERS_MAP[modifier]
+    return mask
+
+VIEW_ITEM_MAP = {}
+
+def _remove_mnemonic(label):
+    """Remove the underscore used by GTK for mnemonics.
+
+    We totally ignore them on OSX, since they are now deprecated.
+    """
+    return label.replace("_", "")
+
+def handle_menu_activate(ns_menu_item):
+    """Handle a menu item being activated.
+
+    This gets called by our application delegate.
+    """
+
+    menu_item = ns_menu_item.representedObject()
+    menu_item.emit("activate")
+    menubar = menu_item._find_menubar()
+    if menubar is not None:
+        menubar.emit("activate", menu_item.name)
+
+class MenuItemBase(signals.SignalEmitter):
+    """Base class for MenuItem and Separator"""
+    def __init__(self):
+        signals.SignalEmitter.__init__(self)
+        self.name = None
+        self.parent = None
+
+    def show(self):
+        self._menu_item.setHidden_(False)
+
+    def hide(self):
+        self._menu_item.setHidden_(True)
+
+    def enable(self):
+        self._menu_item.setEnabled_(True)
+
+    def disable(self):
+        self._menu_item.setEnabled_(False)
+
+    def remove_from_parent(self):
+        """Remove this menu item from it's parent Menu."""
+        if self.parent is not None:
+            self.parent.remove(self)
+
+class MenuItem(MenuItemBase):
+    """See the GTK version of this method for the current docstring."""
+
+    # map Miro action names to standard OSX actions.
+    _STD_ACTION_MAP = {
+        "HideMiro":         (NSApp(), 'hide:'),
+        "HideOthers":       (NSApp(), 'hideOtherApplications:'),
+        "ShowAll":          (NSApp(), 'unhideAllApplications:'),
+        "Cut":              (nil,     'cut:'),
+        "Copy":             (nil,     'copy:'),
+        "Paste":            (nil,     'paste:'),
+        "Delete":           (nil,     'delete:'),
+        "SelectAll":        (nil,     'selectAll:'),
+        "Zoom":             (nil,     'performZoom:'),
+        "Minimize":         (nil,     'performMiniaturize:'),
+        "BringAllToFront":  (nil,     'arrangeInFront:'),
+        "CloseWindow":      (nil,     'performClose:'),
+    }
+
+    def __init__(self, label, name, shortcut=None):
+        MenuItemBase.__init__(self)
+        self.name = name
+        self._menu_item = self._make_menu_item(label)
+        self.create_signal('activate')
+        self._setup_shortcut(shortcut)
+
+    def _make_menu_item(self, label):
+        menu_item = NSMenuItem.alloc().init()
+        menu_item.setTitle_(_remove_mnemonic(label))
+        # we set ourselves as the represented object for the menu item so we
+        # can easily translate one to the other
+        menu_item.setRepresentedObject_(self)
+        if self.name in self._STD_ACTION_MAP:
+            menu_item.setTarget_(self._STD_ACTION_MAP[self.name][0])
+            menu_item.setAction_(self._STD_ACTION_MAP[self.name][1])
+        else:
+            menu_item.setTarget_(NSApp().delegate())
+            menu_item.setAction_('handleMenuActivate:')
+        return menu_item
+
+    def _setup_shortcut(self, shortcut):
+        if shortcut is None:
+            key = ''
+            modifier_mask = 0
+        elif isinstance(shortcut.shortcut, str):
+            key = shortcut.shortcut
+            modifier_mask = make_modifier_mask(shortcut)
+        elif shortcut.shortcut in KEYS_MAP:
+            key = KEYS_MAP[shortcut.shortcut]
+            modifier_mask = make_modifier_mask(shortcut)
+        else:
+            logging.warn("Don't know how to handle shortcut: %s", shortcut)
+            return
+        self._menu_item.setKeyEquivalent_(key)
+        self._menu_item.setKeyEquivalentModifierMask_(modifier_mask)
+
+    def _change_shortcut(self, shortcut):
+        self._setup_shortcut(shortcut)
+
+    def set_label(self, new_label):
+        self._menu_item.setTitle_(new_label)
+
+    def get_label(self):
+        self._menu_item.title()
+
+    def _find_menubar(self):
+        """Remove this menu item from it's parent Menu."""
+        menu_item = self
+        while menu_item.parent is not None:
+            menu_item = menu_item.parent
+        if isinstance(menu_item, MenuBar):
+            return menu_item
+        else:
+            return None
+
+class CheckMenuItem(MenuItem):
+    """See the GTK version of this method for the current docstring."""
+    def set_state(self, active):
+        if active is None:
+            state = NSMixedState
+        elif active:
+            state = NSOnState
+        else:
+            state = NSOffState
+        self._menu_item.setState_(state)
+
+    def get_state(self):
+        return self._menu_item.state() == NSOnState
+
+    def do_activate(self):
+        if self._menu_item.state() == NSOffState:
+            self._menu_item.setState_(NSOnState)
+        else:
+            self._menu_item.setState_(NSOffState)
+
+class RadioMenuItem(CheckMenuItem):
+    """See the GTK version of this method for the current docstring."""
+    def __init__(self, label, name, shortcut=None):
+        CheckMenuItem.__init__(self, label, name, shortcut)
+        # The leader of a radio group stores the list of all items in the
+        # group
+        self.group_leader = None
+        self.others_in_group = set()
+
+    def set_group(self, group_item):
+        if self.group_leader is not None:
+            raise ValueError("%s is already in a group" % self)
+        if group_item.group_leader is None:
+            group_leader = group_item
+        else:
+            group_leader = group_item.group_leader
+        if group_leader.group_leader is not None:
+            raise AssertionError("group_leader structure is wrong")
+        self.group_leader = group_leader
+        group_leader.others_in_group.add(self)
+
+    def remove_from_group(self):
+        """Remove this RadioMenuItem from its current group."""
+        if self.group_leader is not None:
+            # we have a group leader, remove ourself from their list.
+            # Note that this code will work even if we're the last item in
+            # others_in_group.
+            self.group_leader.others_in_group.remove(self)
+            self.group_leader = None
+        elif len(self.others_in_group) > 1:
+            # we're the group leader, hand off the leader to a different item
+            first_item = iter(self.others_in_group).next()
+            for other in self.others_in_group:
+                if other is first_item:
+                    other.others_in_group = self.others_in_group
+                    other.others_in_group.remove(first_item)
+                    other.group_leader = None
+                else:
+                    other.group_leader = first_item
+            self.others_in_group = set()
+        elif len(self.others_in_group) == 1:
+            # we're the group leader, but there's only 1 other item.  unset
+            # everything.
+            for other in self.others_in_group:
+                other.group_leader = None
+            self.others_in_group = set()
+
+    def _items_in_group(self):
+        if self.group_leader is not None: # we have a group leader
+            yield self.group_leader
+            for other in self.group_leader.others_in_group:
+                yield other
+        elif self.others_in_group: # we're the group leader
+            yield self
+            for other in self.others_in_group:
+                yield other
+        else: # we don't have a group set
+            yield self
+
+    def do_activate(self):
+        for item in self._items_in_group():
+            if item is not self:
+                item.set_state(False)
+        CheckMenuItem.do_activate(self)
+
+class Separator(MenuItemBase):
+    """See the GTK version of this method for the current docstring."""
+    def __init__(self):
+        MenuItemBase.__init__(self)
+        self._menu_item = NSMenuItem.separatorItem()
+
+class MenuShell(signals.SignalEmitter):
+    def __init__(self, nsmenu):
+        signals.SignalEmitter.__init__(self)
+        self._menu = nsmenu
+        self.children = []
+        self.parent = None
+
+    def append(self, menu_item):
+        """Add a menu item to the end of this menu."""
+        self.children.append(menu_item)
+        self._menu.addItem_(menu_item._menu_item)
+        menu_item.parent = self
+
+    def insert(self, index, menu_item):
+        """Insert a menu item in the middle of this menu."""
+        self.children.insert(index, menu_item)
+        self._menu.insertItem_atIndex_(menu_item._menu_item, index)
+        menu_item.parent = self
+
+    def index(self, name):
+        """Find the position of a child menu item."""
+        for i, menu_item in enumerate(self.children):
+            if menu_item.name == name:
+                return i
+        return -1
+
+    def remove(self, menu_item):
+        """Remove a child menu item.
+
+        :raises ValueError: menu_item is not a child of this menu
+        """
+        self.children.remove(menu_item)
+        self._menu.removeItem_(menu_item._menu_item)
+        menu_item.parent = None
+
+    def get_children(self):
+        """Get the child menu items in order."""
+        return list(self.children)
+
+    def find(self, name):
+        """Search for a menu or menu item
+
+        This method recursively searches the entire menu structure for a Menu
+        or MenuItem object with a given name.
+
+        :raises KeyError: name not found
+        """
+        found = self._find(name)
+        if found is None:
+            raise KeyError(name)
+        else:
+            return found
+
+    def _find(self, name):
+        """Low-level helper-method for find().
+
+        :returns: found menu item or None.
+        """
+        for menu_item in self.get_children():
+            if menu_item.name == name:
+                return menu_item
+            if isinstance(menu_item, Menu):
+                submenu_find = menu_item._find(name)
+                if submenu_find is not None:
+                    return submenu_find
+        return None
+
+class Menu(MenuShell):
+    """See the GTK version of this method for the current docstring."""
+    def __init__(self, label, name, child_items=None):
+        MenuShell.__init__(self, NSMenu.alloc().init())
+        self._menu.setTitle_(_remove_mnemonic(label))
+        # we will enable/disable menu items manually
+        self._menu.setAutoenablesItems_(False)
+        self.name = name
+        if child_items is not None:
+            for item in child_items:
+                self.append(item)
+        self._menu_item = NSMenuItem.alloc().init()
+        self._menu_item.setTitle_(_remove_mnemonic(label))
+        self._menu_item.setSubmenu_(self._menu)
+        # Hack to set the services menu
+        if name == "ServicesMenu":
+            NSApp().setServicesMenu_(self._menu_item)
+
+    def show(self):
+        self._menu_item.setHidden_(False)
+
+    def hide(self):
+        self._menu_item.setHidden_(True)
+
+    def enable(self):
+        self._menu_item.setEnabled_(True)
+
+    def disable(self):
+        self._menu_item.setEnabled_(False)
+
+class AppMenu(MenuShell):
+    """Wrapper for the application menu (AKA the Miro menu)
+
+    We need to special case this because OSX automatically creates the menu
+    item.
+    """
+    def __init__(self):
+        MenuShell.__init__(self, NSApp().mainMenu().itemAtIndex_(0).submenu())
+        self.name = "Libre Video Converter"
+
+class MenuBar(MenuShell):
+    """See the GTK version of this method for the current docstring."""
+    def __init__(self):
+        MenuShell.__init__(self, NSApp().mainMenu())
+        self.create_signal('activate')
+        self._add_app_menu()
+
+    def _add_app_menu(self):
+        """Add the app menu to this menu bar.
+
+        We need to special case this because OSX automatically adds the
+        NSMenuItem for the app menu, we just need to set up our wrappers.
+        """
+        self._app_menu = AppMenu()
+        self.children.append(self._app_menu)
+        self._app_menu.parent = self
+
+    def add_initial_menus(self, menus):
+        for menu in menus:
+            self.append(menu)
+        self._modify_initial_menus()
+
+    def _extract_menu_item(self, name):
+        """Helper method for changing the portable menu structure."""
+        menu_item = self.find(name)
+        menu_item.remove_from_parent()
+        return menu_item
+
+    def _modify_initial_menus(self):
+        short_appname = "Libre Video Converter"    # XXX
+
+        # Application menu
+        miroMenuItems = [
+            self._extract_menu_item("About"),
+            Separator(),
+            self._extract_menu_item("Quit")
+        ]
+
+        for item in miroMenuItems:
+            self._app_menu.append(item)
+
+        self._app_menu.find("Quit").set_label(_("Quit %(appname)s",
+                                       {"appname": short_appname}))
+
+        # Help Menu
+        #helpItem = self.find("Help")
+        #helpItem.set_label(_("%(appname)s Help", {"appname": short_appname}))
+        #helpItem._change_shortcut(Shortcut("?", MOD))
+
+        self._update_present_menu()
+        self._connect_to_signals()
+
+    def do_activate(self, name):
+        # We handle a couple OSX-specific actions here
+        if name == "PresentActualSize":
+            NSApp().delegate().present_movie('natural-size')
+        elif name == "PresentDoubleSize":
+            NSApp().delegate().present_movie('double-size')
+        elif name == "PresentHalfSize":
+            NSApp().delegate().present_movie('half-size')
+        elif name == "ShowMain":
+            app.widgetapp.window.nswindow.makeKeyAndOrderFront_(self)
+
+    def _connect_to_signals(self):
+        return
+        app.playback_manager.connect("will-play", self._on_playback_change)
+        app.playback_manager.connect("will-stop", self._on_playback_change)
+
+    def _on_playback_change(self, playback_manager, *args):
+        self._update_present_menu()
+
+    def _update_present_menu(self):
+        return
+        if self._should_enable_present_menu():
+            for menu_item in self.present_menu.get_children():
+                menu_item.enable()
+        else:
+            for menu_item in self.present_menu.get_children():
+                menu_item.disable()
+
+    def _should_enable_present_menu(self):
+        return False
+        if (app.playback_manager.is_playing and
+            not app.playback_manager.is_playing_audio):
+            # we're currently playing video, allow the user to fullscreen
+            return True
+        selection_info = app.item_list_controller_manager.get_selection_info()
+        if (selection_info.has_download and
+            selection_info.has_file_type('video')):
+            # A downloaded video is selected, allow the user to start playback
+            # in fullscreen
+            return True
+        return False
+
+#class ContextMenuHandler(NSObject):
+#    def initWithCallback_(self, callback):
+#        self = super(ContextMenuHandler, self).init()
+#        self.callback = callback
+#        return self
+#
+#    def handleMenuItem_(self, sender):
+#        self.callback()
+#
+#class MiroContextMenu(NSMenu):
+#    # Works exactly like NSMenu, except it keeps a reference to the menu
+#    # handler objects.
+#    def init(self):
+#        self = super(MiroContextMenu, self).init()
+#        self.handlers = set()
+#        return self
+#
+#    def addItem_(self, item):
+#        if isinstance(item.target(), ContextMenuHandler):
+#            self.handlers.add(item.target())
+#        return NSMenu.addItem_(self, item)
+#
+def make_context_menu(menu_items):
+    nsmenu = MiroContextMenu.alloc().init()
+    for item in menu_items:
+        if item is None:
+            nsitem = NSMenuItem.separatorItem()
+        else:
+            label, callback = item
+            nsitem = NSMenuItem.alloc().init()
+            if isinstance(label, tuple) and len(label) == 2:
+                label, icon_path = label
+                image = NSImage.alloc().initWithContentsOfFile_(icon_path)
+                nsitem.setImage_(image)
+            if callback is None:
+                font_size = NSFont.systemFontSize()
+                font = NSFont.fontWithName_size_("Lucida Sans Italic", font_size)
+                if font is None:
+                    font = NSFont.systemFontOfSize_(font_size)
+                attributes = {NSFontAttributeName: font}
+                attributed_label = NSAttributedString.alloc().initWithString_attributes_(label, attributes)
+                nsitem.setAttributedTitle_(attributed_label)
+            else:
+                nsitem.setTitle_(label)
+                if isinstance(callback, list):
+                    submenu = make_context_menu(callback)
+                    nsmenu.setSubmenu_forItem_(submenu, nsitem)
+                else:
+                    handler = ContextMenuHandler.alloc().initWithCallback_(callback)
+                    nsitem.setTarget_(handler)
+                    nsitem.setAction_('handleMenuItem:')
+        nsmenu.addItem_(nsitem)
+    return nsmenu
+
+def translate_event_modifiers(event):
+    mods = set()
+    flags = event.modifierFlags()
+    if flags & NSCommandKeyMask:
+        mods.add(keyboard.CMD)
+    if flags & NSControlKeyMask:
+        mods.add(keyboard.CTRL)
+    if flags & NSAlternateKeyMask:
+        mods.add(keyboard.ALT)
+    if flags & NSShiftKeyMask:
+        mods.add(keyboard.SHIFT)
+    return mods
diff --git a/lvc/widgets/osx/rect.py b/lvc/widgets/osx/rect.py
new file mode 100644
index 0000000..3c8d448
--- /dev/null
+++ b/lvc/widgets/osx/rect.py
@@ -0,0 +1,78 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".rect -- Simple Rectangle class."""
+
+from Foundation import NSMakeRect, NSRectFromString
+
+class Rect(object):
+    @classmethod
+    def from_string(cls, rect_string):
+        if rect_string.startswith('{{'):
+            return NSRectWrapper(NSRectFromString(rect_string))
+        else:
+            try:
+                items = [int(i) for i in rect_string.split(',')]
+                return Rect(*items)
+            except:
+                return None
+
+    def __init__(self, x, y, width, height):
+        self.nsrect = NSMakeRect(x, y, width, height)
+
+    def get_x(self):
+        return self.nsrect.origin.x
+    def set_x(self, x):
+        self.nsrect.origin.x = x
+    x = property(get_x, set_x)
+
+    def get_y(self):
+        return self.nsrect.origin.y
+    def set_y(self, y):
+        self.nsrect.origin.x = y
+    y = property(get_y, set_y)
+
+    def get_width(self):
+        return self.nsrect.size.width
+    def set_width(self, width):
+        self.nsrect.size.width = width
+    width = property(get_width, set_width)
+
+    def get_height(self):
+        return self.nsrect.size.height
+    def set_height(self, height):
+        self.nsrect.size.height = height
+    height = property(get_height, set_height)
+
+    def __str__(self):
+        return "%d,%d,%d,%d" % (self.nsrect.origin.x, self.nsrect.origin.y, self.nsrect.size.width, self.nsrect.size.height)
+
+class NSRectWrapper(Rect):
+    def __init__(self, nsrect):
+        self.nsrect = nsrect
diff --git a/lvc/widgets/osx/simple.py b/lvc/widgets/osx/simple.py
new file mode 100644
index 0000000..37407a1
--- /dev/null
+++ b/lvc/widgets/osx/simple.py
@@ -0,0 +1,376 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+from __future__ import division
+import logging
+import math
+
+from AppKit import *
+from Foundation import *
+from objc import YES, NO, nil
+
+from lvc.widgets import widgetconst
+from .base import Widget, SimpleBin, FlippedView
+from .utils import filename_to_unicode
+import drawing
+import wrappermap
+
+"""A collection of various simple widgets."""
+
+class Image(object):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self, path):
+        self._set_image(NSImage.alloc().initByReferencingFile_(
+            filename_to_unicode(path)))
+
+    def _set_image(self, nsimage):
+        self.nsimage = nsimage
+        self.width = self.nsimage.size().width
+        self.height = self.nsimage.size().height
+        if self.width * self.height == 0:
+            raise ValueError('Image has invalid size: (%d, %d)' % (
+                    self.width, self.height))
+
+    def resize(self, width, height):
+        return ResizedImage(self, width, height)
+
+    def crop_and_scale(self, src_x, src_y, src_width, src_height, dest_width,
+            dest_height):
+        if dest_width <= 0 or dest_height <= 0:
+            logging.stacktrace("invalid dest sizes: %s %s" % (dest_width,
+                    dest_height))
+            return TransformedImage(self.nsimage)
+
+        source_rect = NSMakeRect(src_x, src_y, src_width, src_height)
+        dest_rect = NSMakeRect(0, 0, dest_width, dest_height)
+
+        dest = NSImage.alloc().initWithSize_(NSSize(dest_width, dest_height))
+        dest.lockFocus()
+        try:
+            NSGraphicsContext.currentContext().setImageInterpolation_(
+                    NSImageInterpolationHigh)
+            self.nsimage.drawInRect_fromRect_operation_fraction_(dest_rect,
+                    source_rect, NSCompositeCopy, 1.0)
+        finally:
+            dest.unlockFocus()
+        return TransformedImage(dest)
+
+    def resize_for_space(self, width, height):
+        """Returns an image scaled to fit into the specified space at the
+        correct height/width ratio.
+        """
+        # this prevents division by 0.
+        if self.width == 0 and self.height == 0:
+            return self
+        elif self.width == 0:
+            ratio = height / self.height
+            return self.resize(self.width, ratio * self.height)
+        elif self.height == 0:
+            ratio = width / self.width
+            return self.resize(ratio * self.width, self.height)
+
+        ratio = min(width / self.width, height / self.height)
+        return self.resize(ratio * self.width, ratio * self.height)
+
+class ResizedImage(Image):
+    def __init__(self, image, width, height):
+        nsimage = image.nsimage.copy()
+        nsimage.setCacheMode_(NSImageCacheNever)
+        nsimage.setScalesWhenResized_(YES)
+        nsimage.setSize_(NSSize(width, height))
+        self._set_image(nsimage)
+
+class TransformedImage(Image):
+    def __init__(self, nsimage):
+        self._set_image(nsimage)
+
+class NSImageDisplay(NSView):
+    def init(self):
+        self = super(NSImageDisplay, self).init()
+        self.border = False
+        self.image = None
+        return self
+
+    def isFlipped(self):
+        return YES
+
+    def set_border(self, border):
+        self.border = border
+
+    def set_image(self, image):
+        self.image = image
+
+    def drawRect_(self, dest_rect):
+        if self.image is not None:
+            source_rect = self.calculateSourceRectFromDestRect_(dest_rect)
+            context = NSGraphicsContext.currentContext()
+            context.setShouldAntialias_(YES)
+            context.setImageInterpolation_(NSImageInterpolationHigh)
+            context.saveGraphicsState()
+            drawing.flip_context(self.bounds().size.height)
+            self.image.nsimage.drawInRect_fromRect_operation_fraction_(
+                dest_rect, source_rect, NSCompositeSourceOver, 1.0)
+            context.restoreGraphicsState()
+        if self.border:
+            context = drawing.DrawingContext(self, self.bounds(), dest_rect)
+            context.style = drawing.DrawingStyle()
+            context.set_line_width(1)
+            context.set_color((0, 0, 0))    # black
+            context.rectangle(0, 0, context.width, context.height)
+            context.stroke()
+
+    def calculateSourceRectFromDestRect_(self, dest_rect):
+        """Calulate where dest_rect maps to on our image.
+
+        This is tricky because our image might be scaled up, in which case
+        the rect from our image will be smaller than dest_rect.
+        """
+        view_size = self.frame().size
+        x_scale = float(self.image.width) / view_size.width
+        y_scale = float(self.image.height) / view_size.height
+
+        return NSMakeRect(dest_rect.origin.x * x_scale,
+                dest_rect.origin.y * y_scale,
+                dest_rect.size.width * x_scale,
+                dest_rect.size.height * y_scale)
+
+    # XXX FIXME: should track mouse movement - mouseDown is not the correct
+    # event.
+    def mouseDown_(self, event):
+        wrappermap.wrapper(self).emit('clicked')
+
+class ImageDisplay(Widget):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self, image=None):
+        Widget.__init__(self)
+        self.create_signal('clicked')
+        self.view = NSImageDisplay.alloc().init()
+        self.set_image(image)
+
+    def set_image(self, image):
+        self.image = image
+        if image:
+            image.nsimage.setCacheMode_(NSImageCacheNever)
+        self.view.set_image(image)
+        self.invalidate_size_request()
+
+    def set_border(self, border):
+        self.view.set_border(border)
+
+    def calc_size_request(self):
+        if self.image is not None:
+            return self.image.width, self.image.height
+        else:
+            return 0, 0
+
+class ClickableImageButton(ImageDisplay):
+    def __init__(self, image_path, max_width=None, max_height=None):
+        ImageDisplay.__init__(self)
+        self.set_border(True)
+        self.max_width = max_width
+        self.max_height = max_height
+        self.image = None
+        self._width, self._height = None, None
+        if image_path:
+            self.set_path(image_path)
+
+    def set_path(self, path):
+        image = Image(path)
+        if self.max_width:
+            image = image.resize_for_space(self.max_width, self.max_height)
+        super(ClickableImageButton, self).set_image(image)
+
+    def calc_size_request(self):
+        if self.max_width:
+            return self.max_width, self.max_height
+        else:
+            return ImageDisplay.calc_size_request(self)
+
+class MiroImageView(NSImageView):
+    def viewWillMoveToWindow_(self, aWindow):
+        self.setAnimates_(not aWindow == nil)
+
+class AnimatedImageDisplay(Widget):
+    def __init__(self, path):
+        Widget.__init__(self)
+        self.nsimage = NSImage.alloc().initByReferencingFile_(
+          filename_to_unicode(path))
+        self.view = MiroImageView.alloc().init()
+        self.view.setImage_(self.nsimage)
+        # enabled when viewWillMoveToWindow:aWindow invoked
+        self.view.setAnimates_(NO)
+
+    def calc_size_request(self):
+        return self.nsimage.size().width, self.nsimage.size().height
+
+class Label(Widget):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self, text="", wrap=False, color=None):
+        Widget.__init__(self)
+        self.view = NSTextField.alloc().init()
+        self.view.setEditable_(NO)
+        self.view.setBezeled_(NO)
+        self.view.setBordered_(NO)
+        self.view.setDrawsBackground_(NO)
+        self.wrap = wrap
+        self.bold = False
+        self.size = NSFont.systemFontSize()
+        self.sizer_cell = self.view.cell().copy()
+        self.set_font()
+        self.set_text(text)
+        self.__color = self.view.textColor()
+        if color is not None:
+            self.set_color(color)
+
+    def get_width(self):
+        return self.calc_size_request()[0]
+
+    def set_bold(self, bold):
+        self.bold = bold
+        self.set_font()
+
+    def set_size(self, size):
+        if size > 0:
+            self.size = NSFont.systemFontSize() * size
+        elif size == widgetconst.SIZE_SMALL:
+            self.size = NSFont.smallSystemFontSize()
+        elif size == widgetconst.SIZE_NORMAL:
+            self.size = NSFont.systemFontSize()
+        else:
+            raise ValueError("Unknown size constant: %s" % size)
+
+        self.set_font()
+
+    def set_color(self, color):
+        self.__color = self.make_color(color)
+
+        if self.view.isEnabled():
+            self.view.setTextColor_(self.__color)
+        else:
+            self.view.setTextColor_(self.__color.colorWithAlphaComponent_(0.5))
+
+    def set_background_color(self, color):
+        self.view.setBackgroundColor_(self.make_color(color))
+        self.view.setDrawsBackground_(YES)
+
+    def set_font(self):
+        if self.bold:
+            font = NSFont.boldSystemFontOfSize_(self.size)
+        else:
+            font= NSFont.systemFontOfSize_(self.size)
+        self.view.setFont_(font)
+        self.sizer_cell.setFont_(font)
+        self.invalidate_size_request()
+
+    def calc_size_request(self):
+        if (self.wrap and self.manual_size_request is not None and
+                self.manual_size_request[0] > 0):
+            wrap_width = self.manual_size_request[0]
+            size = self.sizer_cell.cellSizeForBounds_(NSMakeRect(0, 0,
+                wrap_width, 10000))
+        else:
+            size = self.sizer_cell.cellSize()
+        return math.ceil(size.width), math.ceil(size.height)
+
+    def baseline(self):
+        return -self.view.font().descender()
+
+    def set_text(self, text):
+        self.view.setStringValue_(text)
+        self.sizer_cell.setStringValue_(text)
+        self.invalidate_size_request()
+
+    def get_text(self):
+        val = self.view.stringValue()
+        if not val:
+            val = u''
+        return val
+
+    def set_selectable(self, val):
+        self.view.setSelectable_(val)
+
+    def set_alignment(self, alignment):
+        self.view.setAlignment_(alignment)
+
+    def get_alignment(self, alignment):
+        return self.view.alignment()
+
+    def set_wrap(self, wrap):
+        self.wrap = True
+        self.invalidate_size_request()
+
+    def enable(self):
+        Widget.enable(self)
+        self.view.setTextColor_(self.__color)
+        self.view.setEnabled_(True)
+
+    def disable(self):
+        Widget.disable(self)
+        self.view.setTextColor_(self.__color.colorWithAlphaComponent_(0.5))
+        self.view.setEnabled_(False)
+
+class SolidBackground(SimpleBin):
+    def __init__(self,  color=None):
+        SimpleBin.__init__(self)
+        self.view = FlippedView.alloc().init()
+        if color is not None:
+            self.set_background_color(color)
+
+    def set_background_color(self, color):
+        self.view.setBackgroundColor_(self.make_color(color))
+
+class ProgressBar(Widget):
+    def __init__(self):
+        Widget.__init__(self)
+        self.view = NSProgressIndicator.alloc().init()
+        self.view.setMaxValue_(1.0)
+        self.view.setIndeterminate_(False)
+
+    def calc_size_request(self):
+        return 20, 20
+
+    def set_progress(self, fraction):
+        self.view.setIndeterminate_(False)
+        self.view.setDoubleValue_(fraction)
+
+    def start_pulsing(self):
+        self.view.setIndeterminate_(True)
+        self.view.startAnimation_(nil)
+
+    def stop_pulsing(self):
+        self.view.stopAnimation_(nil)
+
+class HLine(Widget):
+    def __init__(self):
+        Widget.__init__(self)
+        self.view = NSBox.alloc().init()
+        self.view.setBoxType_(NSBoxSeparator)
+
+    def calc_size_request(self):
+        return self.view.frame().size.width, self.view.frame().size.height
diff --git a/lvc/widgets/osx/tablemodel.py b/lvc/widgets/osx/tablemodel.py
new file mode 100644
index 0000000..d81a8f5
--- /dev/null
+++ b/lvc/widgets/osx/tablemodel.py
@@ -0,0 +1,532 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""tablemodel.py -- Model classes for TableView.  """
+
+import logging
+
+from AppKit import (NSDragOperationNone, NSDragOperationAll, NSTableViewDropOn,
+                    NSOutlineViewDropOnItemIndex, protocols)
+from Foundation import NSObject, NSNotFound, NSMutableIndexSet
+from objc import YES, NO, nil
+
+from lvc import signals
+from lvc.errors import WidgetActionError
+import fasttypes
+import wrappermap
+
+MIRO_DND_ITEM_LOCAL = 'miro-local-item'
+
+# XXX need unsigned but value comes out as signed.
+NSDragOperationEvery = NSDragOperationAll
+
+def list_from_nsindexset(index_set):
+    rows = list()
+    index = index_set.firstIndex()
+    while (index != NSNotFound):
+        rows.append(index)
+        index = index_set.indexGreaterThanIndex_(index)
+    return rows
+
+class RowList(object):
+    """RowList is a Linked list that has some optimizations for looking up
+    rows by index number.
+    """
+    def __init__(self):
+        self.list = fasttypes.LinkedList()
+        self.iter_cache = []
+
+    def firstIter(self):
+        return self.list.firstIter()
+
+    def lastIter(self):
+        return self.list.lastIter()
+
+    def insertBefore(self, iter, value):
+        self.iter_cache = []
+        if iter is None:
+            return self.list.append(value)
+        else:
+            return self.list.insertBefore(iter, value)
+
+    def append(self, value):
+        return self.list.append(value)
+
+    def __len__(self):
+        return len(self.list)
+
+    def __getitem__(self, iter):
+        return self.list[iter]
+
+    def __iter__(self):
+        iter = self.firstIter()
+        while iter != self.lastIter():
+            yield iter.value()
+            iter.forward()
+
+    def remove(self, iter):
+        self.iter_cache = []
+        return self.list.remove(iter)
+
+    def nth_iter(self, index):
+        if index < 0:
+            raise IndexError(index)
+        elif index >= len(self):
+            raise LookupError()
+        if len(self.iter_cache) == 0:
+            self.iter_cache.append(self.firstIter())
+        try:
+            return self.iter_cache[index].copy()
+        except IndexError:
+            pass
+        iter = self.iter_cache[-1].copy()
+        index -= len(self.iter_cache) - 1
+        for x in xrange(index):
+            iter.forward()
+            self.iter_cache.append(iter.copy())
+        return iter
+
+class TableModelBase(signals.SignalEmitter):
+    """Base class for TableModel and TreeTableModel."""
+    def __init__(self, *column_types):
+        signals.SignalEmitter.__init__(self)
+        self.row_list = RowList()
+        self.column_types = column_types
+        self.create_signal('row-changed')
+        self.create_signal('structure-will-change')
+
+    def check_column_values(self, column_values):
+        if len(self.column_types) != len(column_values):
+            raise ValueError("Wrong number of columns")
+        # We might want to do more typechecking here
+
+    def get_column_data(self, row, column):
+        attr_map = column.attrs()
+        return dict((name, row[index]) for name, index in attr_map.items())
+
+    def update_value(self, iter, index, value):
+        iter.value().values[index] = value
+        self.emit('row-changed', iter)
+
+    def update(self, iter, *column_values):
+        iter.value().update_values(column_values)
+        self.emit('row-changed', iter)
+
+    def remove(self, iter):
+        self.emit('structure-will-change')
+        row_list = self.containing_list(iter)
+        rv = row_list.remove(iter)
+        if rv == row_list.lastIter():
+            rv = None
+        return rv
+
+    def nth_iter(self, index):
+        return self.row_list.nth_iter(index)
+
+    def next_iter(self, iter):
+        row_list = self.containing_list(iter)
+        retval = iter.copy()
+        retval.forward()
+        if retval == row_list.lastIter():
+            return None
+        else:
+            return retval
+
+    def first_iter(self):
+        if len(self.row_list) > 0:
+            return self.row_list.firstIter()
+        else:
+            return None
+
+    def __len__(self):
+        return len(self.row_list)
+
+    def __getitem__(self, iter):
+        return iter.value()
+
+    def __iter__(self):
+        return iter(self.row_list)
+
+class TableRow(object):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPITableView for a description of the API for this class."""
+    def __init__(self, column_values):
+        self.update_values(column_values)
+
+    def update_values(self, column_values):
+        self.values = list(column_values)
+
+    def __getitem__(self, index):
+        return self.values[index]
+
+    def __len__(self):
+        return len(self.values)
+
+    def __iter__(self):
+        return iter(self.values)
+
+class TableModel(TableModelBase):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPITableView for a description of the API for this class."""
+    def __init__(self, *column_types):
+        TableModelBase.__init__(self, column_types)
+        self.row_indexes = {}
+
+    def remember_row_at_index(self, row, index):
+        if row not in self.row_indexes:
+            self.row_indexes[row] = index
+
+    def row_of_iter(self, tableview, iter):
+        row = iter.value()
+        try:
+            return self.row_indexes[row]
+        except KeyError:
+            iter = self.row_list.firstIter()
+            index = 0
+            while iter != self.row_list.lastIter():
+                current_row = iter.value()
+                self.row_indexes[current_row] = index
+                if current_row is row:
+                    return index
+                index += 1
+                iter.forward()
+            raise LookupError("%s is not in this table" % row)
+
+    def containing_list(self, iter):
+        return self.row_list
+
+    def append(self, *column_values):
+        self.emit('structure-will-change')
+        self.row_indexes = {}
+        retval = self.row_list.append(TableRow(column_values))
+        return retval
+
+    def remove(self, iter):
+        self.row_indexes = {}
+        return TableModelBase.remove(self, iter)
+
+    def insert_before(self, iter, *column_values):
+        self.emit('structure-will-change')
+        self.row_indexes = {}
+        row = TableRow(column_values)
+        retval = self.row_list.insertBefore(iter, row)
+        return retval
+
+    def iter_for_row(self, tableview, row):
+        return self.row_list.nth_iter(row)
+
+
+class TreeNode(NSObject, TableRow):
+    """A row in a TreeTableModel"""
+
+    # Implementation note: these need to be NSObjects because we return them
+    # to the NSOutlineView.
+
+    def initWithValues_parent_(self, column_values, parent):
+        self.children = RowList()
+        self.update_values(column_values)
+        self.parent = parent
+        return self
+
+    @staticmethod
+    def create_(values, parent):
+        return TreeNode.alloc().initWithValues_parent_(values, parent)
+
+    def iterchildren(self):
+        return iter(self.children)
+
+class TreeTableModel(TableModelBase):
+    """https://develop.participatoryculture.org/index.php/WidgetAPITableView"""
+    def __init__(self, *column_values):
+        TableModelBase.__init__(self, *column_values)
+        self.iter_for_item = {}
+
+    def containing_list(self, iter):
+        return self.row_list_for_iter(iter.value().parent)
+
+    def row_list_for_iter(self, iter):
+        """Return the rows of all direct children of iter."""
+        if iter is None:
+            return self.row_list
+        else:
+            return iter.value().children
+
+    def remember_iter(self, iter):
+        self.iter_for_item[iter.value()] = iter
+        return iter
+
+    def append(self, *column_values):
+        self.emit('structure-will-change')
+        retval = self.row_list.append(TreeNode.create_(column_values, None))
+        return self.remember_iter(retval)
+
+    def forget_iter_for_item(self, item):
+        del self.iter_for_item[item]
+        for child in item.children:
+            self.forget_iter_for_item(child)
+
+    def remove(self, iter):
+        item = iter.value()
+        rv = TableModelBase.remove(self, iter)
+        self.forget_iter_for_item(item)
+        return rv
+
+    def insert_before(self, iter, *column_values):
+        self.emit('structure-will-change')
+        row = TreeNode.create_(column_values, self.parent_iter(iter))
+        retval = self.containing_list(iter).insertBefore(iter, row)
+        return self.remember_iter(retval)
+
+    def append_child(self, iter, *column_values):
+        self.emit('structure-will-change')
+        row_list = self.row_list_for_iter(iter)
+        retval = row_list.append(TreeNode.create_(column_values, iter))
+        return self.remember_iter(retval)
+
+    def child_iter(self, iter):
+        row_list = iter.value().children
+        if len(row_list) == 0:
+            return None
+        else:
+            return row_list.firstIter()
+
+    def nth_child_iter(self, iter, index):
+        row_list = self.row_list_for_iter(iter)
+        return row_list.nth_iter(index)
+
+    def has_child(self, iter):
+        return len(iter.value().children) > 0
+
+    def children_count(self, iter):
+        if iter is not None:
+            return len(iter.value().children)
+        else:
+            return len(self.row_list)
+
+    def children_iters(self, iter):
+        return self.iters_in_rowlist(self.row_list_for_iter(iter))
+
+    def parent_iter(self, iter):
+        return iter.value().parent
+
+    def iter_for_row(self, tableview, row):
+        item = tableview.itemAtRow_(row)
+        if item in self.iter_for_item:
+            return self.iter_for_item[item]
+        elif item == -1:
+            raise WidgetActionError("no item at row %s" % row)
+        else:
+            raise WidgetActionError("no iter for item %s at row %s" %
+                                   (repr(item), row))
+
+    def row_of_iter(self, tableview, iter):
+        item = iter.value()
+        row = tableview.rowForItem_(item)
+        if row == -1:
+            raise LookupError("%s is not in this table" % repr(item))
+        return row
+
+    def get_path(self, iter_):
+        """Not implemented (yet?) for Cocoa. Currently the only place this is
+        needed is tablistmanager, where the situation that uses paths results
+        from GTK peculiarities.
+        """
+        return NotImplemented
+
+class DataSourceBase(NSObject):
+    def initWithModel_(self, model):
+        self.model = model
+        self.drag_source = None
+        self.drag_dest = None
+        return self
+
+    def setDragSource_(self, drag_source):
+        self.drag_source = drag_source
+
+    def setDragDest_(self, drag_dest):
+        self.drag_dest = drag_dest
+
+    def view_writeColumnData_ToPasteboard_(self, view, data, pasteboard):
+        if not self.drag_source:
+            return NO
+        wrapper = wrappermap.wrapper(view)
+        drag_data = self.drag_source.begin_drag(wrapper, data)
+        if not drag_data:
+            return NO
+        pasteboard.declareTypes_owner_((MIRO_DND_ITEM_LOCAL,), self)
+        for typ, value in drag_data.items():
+            stringval = repr((repr(value), typ))
+            pasteboard.setString_forType_(stringval, MIRO_DND_ITEM_LOCAL)
+        return YES
+
+    def calcType_(self, drag_info):
+        source_actions = drag_info.draggingSourceOperationMask()
+        if not (self.drag_dest and
+                (self.drag_dest.allowed_actions() | source_actions)):
+            return None
+        types = self.drag_dest.allowed_types()
+        available = drag_info.draggingPasteboard().availableTypeFromArray_(
+            (MIRO_DND_ITEM_LOCAL,))
+        if available:
+            # XXX using eval() sucks.
+            data = eval(drag_info.draggingPasteboard().stringForType_(
+                MIRO_DND_ITEM_LOCAL))
+            if data:
+                _, typ = data
+                return typ
+        return None
+
+    def validateDrop_dragInfo_parentIter_position_(self, view, drag_info,
+            parent, position):
+        typ = self.calcType_(drag_info)
+        if typ:
+            wrapper = wrappermap.wrapper(view)
+            drop_action = self.drag_dest.validate_drop(
+                wrapper, self.model, typ,
+                drag_info.draggingSourceOperationMask(), parent,
+                position)
+            if not drop_action:
+                return NSDragOperationNone
+            if isinstance(drop_action, (tuple, list)):
+                drop_action, iter = drop_action
+                view.setDropRow_dropOperation_(
+                    self.model.row_of_iter(view, iter),
+                    NSTableViewDropOn)
+            return drop_action
+        else:
+            return NSDragOperationNone
+
+    def acceptDrop_dragInfo_parentIter_position_(self, view, drag_info,
+            parent, position):
+        typ = self.calcType_(drag_info)
+        if typ:
+            # XXX using eval sucks.
+            data = eval(drag_info.draggingPasteboard().stringForType_(MIRO_DND_ITEM_LOCAL))
+            ids, _ = data
+            ids = eval(ids)
+            wrapper = wrappermap.wrapper(view)
+            self.drag_dest.accept_drop(wrapper, self.model, typ,
+                drag_info.draggingSourceOperationMask(), parent,
+                position, ids)
+            return YES
+        else:
+            return NO
+
+class MiroTableViewDataSource(DataSourceBase, protocols.NSTableDataSource):
+    def numberOfRowsInTableView_(self, table_view):
+        return len(self.model)
+
+    def tableView_objectValueForTableColumn_row_(self, table_view, column, row):
+        node = self.model.nth_iter(row).value()
+        self.model.remember_row_at_index(node, row)
+        return self.model.get_column_data(node.values, column)
+
+    def tableView_writeRowsWithIndexes_toPasteboard_(self, tableview, rowIndexes,
+            pasteboard):
+        indexes = list_from_nsindexset(rowIndexes)
+        data = [self.model[self.model.nth_iter(i)] for i in indexes]
+        return self.view_writeColumnData_ToPasteboard_(tableview, data,
+                pasteboard)
+
+    def translateRow_operation_(self, row, operation):
+        if operation == NSTableViewDropOn:
+            return self.model.nth_iter(row), -1
+        else:
+            return None, row
+
+    def tableView_validateDrop_proposedRow_proposedDropOperation_(self,
+            tableview, drag_info, row, operation):
+        parent, position  = self.translateRow_operation_(row, operation)
+        drop_action = self.validateDrop_dragInfo_parentIter_position_(tableview,
+                drag_info, parent, position)
+        if isinstance(drop_action, (list, tuple)):
+            # XXX nothing uses this yet
+            drop_action, iter = drop_action
+            tableview.setDropRow_dropOperation_(
+                self.model.row_of_iter(tableview, iter),
+                NSTableViewDropOn)
+        return drop_action
+
+    def tableView_acceptDrop_row_dropOperation_(self,
+            tableview, drag_info, row, operation):
+        parent, position = self.translateRow_operation_(row, operation)
+        return self.acceptDrop_dragInfo_parentIter_position_(tableview,
+                drag_info, parent, position)
+
+
+class MiroOutlineViewDataSource(DataSourceBase, protocols.NSOutlineViewDataSource):
+    def outlineView_child_ofItem_(self, view, child, item):
+        if item is nil:
+            row_list = self.model.row_list
+        else:
+            row_list = item.children
+        return row_list.nth_iter(child).value()
+
+    def outlineView_isItemExpandable_(self, view, item):
+        if item is not nil and hasattr(item, 'children'):
+            return len(item.children) > 0
+        else:
+            return len(self.model) > 0
+
+    def outlineView_numberOfChildrenOfItem_(self, view, item):
+        if item is not nil and hasattr(item, 'children'):
+            return len(item.children)
+        else:
+            return len(self.model)
+
+    def outlineView_objectValueForTableColumn_byItem_(self, view, column,
+            item):
+        return self.model.get_column_data(item.values, column)
+
+    def outlineView_writeItems_toPasteboard_(self, outline_view, items,
+            pasteboard):
+        data = [i.values for i in items]
+        return self.view_writeColumnData_ToPasteboard_(outline_view, data,
+                pasteboard)
+
+    def outlineView_validateDrop_proposedItem_proposedChildIndex_(self,
+            outlineview, drag_info, item, child_index):
+        if item is None:
+            iter = None
+        else:
+            iter = self.model.iter_for_item[item]
+        drop_action = self.validateDrop_dragInfo_parentIter_position_(
+            outlineview, drag_info, iter, child_index)
+        if isinstance(drop_action, (tuple, list)):
+            drop_action, iter = drop_action
+            outlineview.setDropItem_dropChildIndex_(
+                iter.value(), NSOutlineViewDropOnItemIndex)
+        return drop_action
+
+    def outlineView_acceptDrop_item_childIndex_(self, outlineview, drag_info,
+            item, child_index):
+        if item is None:
+            iter = None
+        else:
+            iter = self.model.iter_for_item[item]
+        return self.acceptDrop_dragInfo_parentIter_position_(outlineview,
+                drag_info, iter, child_index)
diff --git a/lvc/widgets/osx/tableview.py b/lvc/widgets/osx/tableview.py
new file mode 100644
index 0000000..9f490d2
--- /dev/null
+++ b/lvc/widgets/osx/tableview.py
@@ -0,0 +1,1629 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".tableview -- TableView widget and it's
+associated classes.
+"""
+
+import math
+import logging
+from contextlib import contextmanager
+from collections import namedtuple
+
+from AppKit import *
+from Foundation import *
+from objc import YES, NO, nil
+
+from lvc import signals
+from lvc import errors
+from lvc.widgets import widgetconst
+from lvc.widgets.tableselection import SelectionOwnerMixin
+from lvc.widgets.tablescroll import ScrollbarOwnerMixin
+from .utils import filename_to_unicode
+import wrappermap
+import tablemodel
+import osxmenus
+from .base import Widget
+from .simple import Image
+from .drawing import DrawingContext, DrawingStyle, Gradient, ImageSurface
+from .helpers import NotificationForwarder
+from .layoutmanager import LayoutManager
+
+EXPANDER_PADDING = 6
+HEADER_HEIGHT = 17
+CUSTOM_HEADER_HEIGHT = 25
+
+def iter_range(ns_range):
+    """Iterate over an NSRange object"""
+    return xrange(ns_range.location, ns_range.location + ns_range.length)
+
+Rect = namedtuple('Rect', 'x y width height')
+def NSRectToRect(nsrect):
+    origin, size = nsrect.origin, nsrect.size
+    return Rect(origin.x, origin.y, size.width, size.height)
+
+Point = namedtuple('Point', 'x y')
+def NSPointToPoint(nspoint):
+    return Point(int(nspoint.x), int(nspoint.y))
+
+class HotspotTracker(object):
+    """Contains the info on the currently tracked hotspot.  See:
+    https://develop.participatoryculture.org/index.php/WidgetAPITableView
+    """
+    def __init__(self, tableview, point):
+        self.tableview = tableview
+        self.row = tableview.rowAtPoint_(point)
+        self.column = tableview.columnAtPoint_(point)
+        if self.row == -1 or self.column == -1:
+            self.hit = False
+            return
+        model = tableview.dataSource().model
+        self.iter = model.iter_for_row(tableview, self.row)
+        self.table_column = tableview.tableColumns()[self.column]
+        self.cell = self.table_column.dataCell()
+        self.update_position(point)
+        if isinstance(self.cell, CustomTableCell):
+            self.name = self.calc_hotspot()
+        else:
+            self.name = None
+        self.hit = (self.name is not None)
+
+    def is_for_context_menu(self):
+        return self.name == '#show-context-menu'
+
+    def calc_cell_hotspot(self, column, row):
+        if (self.hit and self.column == column and self.row == row):
+            return self.name
+        else:
+            return None
+
+    def update_position(self, point):
+        cell_frame = self.tableview.frameOfCellAtColumn_row_(self.column,
+                self.row)
+        self.pos = NSPoint(point.x - cell_frame.origin.x,
+                point.y - cell_frame.origin.y)
+
+    def update_hit(self):
+        old_hit = self.hit
+        self.hit = (self.calc_hotspot() == self.name)
+        if old_hit != self.hit:
+            self.redraw_cell()
+
+    def set_cell_data(self):
+        model = self.tableview.dataSource().model
+        row = model[self.iter]
+        value_dict = model.get_column_data(row, self.table_column)
+        self.cell.setObjectValue_(value_dict)
+        self.cell.set_wrapper_data()
+
+    def calc_hotspot(self):
+        self.set_cell_data()
+        cell_frame = self.tableview.frameOfCellAtColumn_row_(self.column,
+                self.row)
+        style = self.cell.make_drawing_style(cell_frame, self.tableview)
+        layout_manager = self.cell.layout_manager
+        layout_manager.reset()
+        return self.cell.wrapper.hotspot_test(style, layout_manager,
+                self.pos.x, self.pos.y, cell_frame.size.width,
+                cell_frame.size.height)
+
+    def redraw_cell(self):
+        # Check to see if we removed the table in response to a hotspot click.
+        if self.tableview.superview() is not nil:
+            cell_frame = self.tableview.frameOfCellAtColumn_row_(self.column,
+                    self.row)
+            self.tableview.setNeedsDisplayInRect_(cell_frame)
+
+def _calc_interior_frame(total_frame, tableview):
+    """Calculate the inner cell area for a table cell.
+
+    We tell cocoa that the intercell spacing is (0, 0) and instead handle the
+    spacing ourselves.  This method calculates the area that a cell should
+    render to, given the total spacing.
+    """
+    return NSMakeRect(total_frame.origin.x + tableview.column_spacing // 2,
+            total_frame.origin.y + tableview.row_spacing // 2,
+            total_frame.size.width - tableview.column_spacing,
+            total_frame.size.height - tableview.row_spacing)
+
+class MiroTableCell(NSTextFieldCell):
+    def init(self):
+        return super(MiroTableCell, self).initTextCell_('')
+
+    def calcHeight_(self, view):
+        font = self.font()
+        return math.ceil(font.ascender() + abs(font.descender()) +
+                font.leading())
+
+    def highlightColorWithFrame_inView_(self, frame, view):
+        return nil
+
+    def setObjectValue_(self, value_dict):
+        if isinstance(value_dict, dict):
+            NSCell.setObjectValue_(self, value_dict['value'])
+        else:
+            # OS X calls setObjectValue_('') on intialization
+            NSCell.setObjectValue_(self, value_dict)
+
+    def drawInteriorWithFrame_inView_(self, frame, view):
+        return NSTextFieldCell.drawInteriorWithFrame_inView_(self,
+                _calc_interior_frame(frame, view), view)
+
+class MiroTableInfoListTextCell(MiroTableCell):
+    def initWithAttrGetter_(self, attr_getter):
+        self = self.init()
+        self.setWraps_(NO)
+        self.attr_getter = attr_getter
+        self._textColor = self.textColor()
+        return self
+
+    def drawWithFrame_inView_(self, frame, view):
+        # adjust frame based on the cell spacing
+        frame = _calc_interior_frame(frame, view)
+        if (self.isHighlighted() and frame is not None and
+            (view.isDescendantOf_(view.window().firstResponder()) or
+             view.gradientHighlight) and view.window().isMainWindow()):
+            self.setTextColor_(NSColor.whiteColor())
+        else:
+            self.setTextColor_(self._textColor)
+        return MiroTableCell.drawWithFrame_inView_(self, frame, view)
+
+    def titleRectForBounds_(self, rect):
+        frame = MiroTableCell.titleRectForBounds_(self, rect)
+        text_size = self.attributedStringValue().size()
+        frame.origin.y = rect.origin.y + (rect.size.height - text_size.height) / 2.0
+        return frame
+
+    def drawInteriorWithFrame_inView_(self, frame, view):
+        rect = self.titleRectForBounds_(frame)
+        self.attributedStringValue().drawInRect_(rect)
+
+    def setObjectValue_(self, value):
+        if isinstance(value, tuple):
+            info, attrs, group_info = value
+            cell_text = self.attr_getter(info)
+            NSCell.setObjectValue_(self, cell_text)
+        else:
+            # Getting set to a something other than a model row, usually this
+            # happens in initialization
+            NSCell.setObjectValue_(self, '')
+
+class MiroTableImageCell(NSImageCell):
+    def calcHeight_(self, view):
+        return self.value_dict['image'].size().height
+
+    def highlightColorWithFrame_inView_(self, frame, view):
+        return nil
+
+    def setObjectValue_(self, value_dict):
+        NSImageCell.setObjectValue_(self, value_dict['image'])
+
+    def drawInteriorWithFrame_inView_(self, frame, view):
+        return NSImageCell.drawInteriorWithFrame_inView_(self,
+                _calc_interior_frame(frame, view), view)
+
+class MiroCheckboxCell(NSButtonCell):
+    def init(self):
+        self = super(MiroCheckboxCell, self).init()
+        self.setButtonType_(NSSwitchButton)
+        self.setTitle_('')
+        return self
+
+    def calcHeight_(self, view):
+        return self.cellSize().height
+
+    def highlightColorWithFrame_inView_(self, frame, view):
+        return nil
+
+    def setObjectValue_(self, value_dict):
+        if isinstance(value_dict, dict):
+            NSButtonCell.setObjectValue_(self, value_dict['value'])
+        else:
+            # OS X calls setObjectValue_('') on intialization
+            NSCell.setObjectValue_(self, value_dict)
+
+    def startTrackingAt_inView_(self, point, view):
+        return YES
+
+    def continueTracking_at_inView_(self, lastPoint, at, view):
+        return YES
+
+    def stopTracking_at_inView_mouseIsUp_(self, lastPoint, at, tableview, mouseIsUp):
+        if mouseIsUp:
+            column = tableview.columnAtPoint_(at)
+            row = tableview.rowAtPoint_(at)
+            if column != -1 and row != -1:
+                wrapper = wrappermap.wrapper(tableview)
+                column = wrapper.columns[column]
+                itr = wrapper.model.iter_for_row(tableview, row)
+                column.renderer.emit('clicked', itr)
+        return NSButtonCell.stopTracking_at_inView_mouseIsUp_(self, lastPoint,
+                at, tableview, mouseIsUp)
+
+    def drawInteriorWithFrame_inView_(self, frame, view):
+        return NSButtonCell.drawInteriorWithFrame_inView_(self,
+                _calc_interior_frame(frame, view), view)
+
+class CellRendererBase(object):
+    DRAW_BACKGROUND = True
+
+    def set_index(self, index):
+        self.index = index
+
+    def get_index(self):
+        return self.index
+
+class CellRenderer(CellRendererBase):
+    def __init__(self):
+        self.cell = self.build_cell()
+        self._font_scale_factor = 1.0
+        self._font_bold = False
+        self.set_align('left')
+
+    def build_cell(self):
+        return MiroTableCell.alloc().init()
+
+    def setDataCell_(self, column):
+        column.setDataCell_(self.cell)
+
+    def set_text_size(self, size):
+        if size == widgetconst.SIZE_NORMAL:
+            self._font_scale_factor = 1.0
+        elif size == widgetconst.SIZE_SMALL:
+            # make the scale factor such so that the font size is 11.0
+            self._font_scale_factor = 11.0 / NSFont.systemFontSize()
+        else:
+            raise ValueError("Unknown size: %s" % size)
+        self._set_font()
+
+    def set_font_scale(self, scale_factor):
+        self._font_scale_factor = scale_factor
+        self._set_font()
+
+    def set_bold(self, bold):
+        self._font_bold = bold
+        self._set_font()
+
+    def _set_font(self):
+        size = NSFont.systemFontSize() * self._font_scale_factor
+        if self._font_bold:
+            font = NSFont.boldSystemFontOfSize_(size)
+        else:
+            font = NSFont.systemFontOfSize_(size)
+        self.cell.setFont_(font)
+
+    def set_color(self, color):
+        color = NSColor.colorWithDeviceRed_green_blue_alpha_(color[0],
+                color[1], color[2], 1.0)
+        self.cell._textColor = color
+        self.cell.setTextColor_(color)
+
+    def set_align(self, align):
+        if align == 'left':
+            ns_alignment = NSLeftTextAlignment
+        elif align == 'center':
+            ns_alignment = NSCenterTextAlignment
+        elif align == 'right':
+            ns_alignment = NSRightTextAlignment
+        else:
+            raise ValueError("unknown alignment: %s", align)
+        self.cell.setAlignment_(ns_alignment)
+
+class ImageCellRenderer(CellRendererBase):
+    def setDataCell_(self, column):
+        column.setDataCell_(MiroTableImageCell.alloc().init())
+
+class CheckboxCellRenderer(CellRendererBase, signals.SignalEmitter):
+    def __init__(self):
+        signals.SignalEmitter.__init__(self, 'clicked')
+        self.size = widgetconst.SIZE_NORMAL
+
+    def set_control_size(self, size):
+        self.size = size
+
+    def setDataCell_(self, column):
+        cell = MiroCheckboxCell.alloc().init()
+        if self.size == widgetconst.SIZE_SMALL:
+            cell.setControlSize_(NSSmallControlSize)
+        column.setDataCell_(cell)
+
+class CustomTableCell(NSCell):
+    def init(self):
+        self = super(CustomTableCell, self).init()
+        self.layout_manager = LayoutManager()
+        self.hotspot = None
+        self.default_drawing_style = DrawingStyle()
+        return self
+
+    def highlightColorWithFrame_inView_(self, frame, view):
+        return nil
+
+    def calcHeight_(self, view):
+        self.layout_manager.reset()
+        self.set_wrapper_data()
+        cell_size = self.wrapper.get_size(self.default_drawing_style,
+                self.layout_manager)
+        return cell_size[1]
+
+    def make_drawing_style(self, frame, view):
+        text_color = None
+        if (self.isHighlighted() and frame is not None and
+                (view.isDescendantOf_(view.window().firstResponder()) or
+                    view.gradientHighlight) and view.window().isMainWindow()):
+            text_color = NSColor.whiteColor()
+        return DrawingStyle(text_color=text_color)
+
+    def drawInteriorWithFrame_inView_(self, frame, view):
+        NSGraphicsContext.currentContext().saveGraphicsState()
+        if not self.wrapper.IGNORE_PADDING:
+            # adjust frame based on the cell spacing. We also have to adjust
+            # the hover position to account for the new frame
+            original_frame = frame
+            frame = _calc_interior_frame(frame, view)
+            hover_adjustment = (frame.origin.x - original_frame.origin.x,
+                                frame.origin.y - original_frame.origin.y)
+        else:
+            hover_adjustment = (0, 0)
+        if self.wrapper.outline_column:
+            pad_left = EXPANDER_PADDING
+        else:
+            pad_left = 0
+        drawing_rect = NSMakeRect(frame.origin.x + pad_left, frame.origin.y,
+                frame.size.width - pad_left, frame.size.height)
+        context = DrawingContext(view, drawing_rect, drawing_rect)
+        context.style = self.make_drawing_style(frame, view)
+        self.layout_manager.reset()
+        self.set_wrapper_data()
+        column = self.wrapper.get_index()
+        hover_pos = view.get_hover(self.row, column)
+        if hover_pos is not None:
+            hover_pos = [hover_pos[0] - hover_adjustment[0],
+                         hover_pos[1] - hover_adjustment[1]]
+        self.wrapper.render(context, self.layout_manager, self.isHighlighted(),
+                self.hotspot, hover_pos)
+        NSGraphicsContext.currentContext().restoreGraphicsState()
+
+    def setObjectValue_(self, value):
+        self.object_value = value
+
+    def set_wrapper_data(self):
+        self.wrapper.__dict__.update(self.object_value)
+
+class CustomCellRenderer(CellRendererBase):
+    CellClass = CustomTableCell
+
+    IGNORE_PADDING = False
+
+    def __init__(self):
+        self.outline_column = False
+        self.index = None
+
+    def setDataCell_(self, column):
+        # Note that the ownership is the opposite of what happens in widgets.
+        # The NSObject owns it's wrapper widget.  This happens for a couple
+        # reasons:
+        # 1) The data cell gets copied a bunch of times, so wrappermap won't
+        # work with it.
+        # 2) The Wrapper should only needs to stay around as long as the
+        # NSCell that it's wrapping is around.  Once the column gets removed
+        # from the table, the wrapper can be deleted.
+        nscell = self.CellClass.alloc().init()
+        nscell.wrapper = self
+        column.setDataCell_(nscell)
+
+    def hotspot_test(self, style, layout, x, y, width, height):
+        return None
+
+class InfoListTableCell(CustomTableCell):
+    def set_wrapper_data(self):
+        self.wrapper.info, self.wrapper.attrs, self.wrapper.group_info = \
+                self.object_value
+
+class InfoListRenderer(CustomCellRenderer):
+    CellClass = InfoListTableCell
+
+    def hotspot_test(self, style, layout, x, y, width, height):
+        return None
+
+class InfoListRendererText(CellRenderer):
+    def build_cell(self):
+        cell = MiroTableInfoListTextCell.alloc()
+        return cell.initWithAttrGetter_(self.get_value)
+
+def calc_row_height(view, model_row):
+    max_height = 0
+    model = view.dataSource().model
+    for column in view.tableColumns():
+        cell = column.dataCell()
+        data = model.get_column_data(model_row, column)
+        cell.setObjectValue_(data)
+        cell_height = cell.calcHeight_(view)
+        max_height = max(max_height, cell_height)
+    if max_height == 0:
+        max_height = 12
+    return max_height + view.row_spacing
+
+class TableViewDelegate(NSObject):
+    def tableView_willDisplayCell_forTableColumn_row_(self, view, cell,
+            column, row):
+        column = view.column_index_map[column]
+        cell.column = column
+        cell.row = row
+        if view.hotspot_tracker:
+            cell.hotspot = view.hotspot_tracker.calc_cell_hotspot(column, row)
+        else:
+            cell.hotspot = None
+
+    def tableView_didClickTableColumn_(self, tableview, column):
+        wrapper = wrappermap.wrapper(tableview)
+        for column_wrapper in wrapper.columns:
+            if column_wrapper._column is column:
+                column_wrapper.emit('clicked')
+
+    def tableView_toolTipForCell_rect_tableColumn_row_mouseLocation_(self, tableview, cell, rect, column, row, location):
+        wrapper = wrappermap.wrapper(tableview)
+        iter = tableview.dataSource().model.iter_for_row(tableview, row)
+        for wrapper_column in wrapper.columns:
+            if wrapper_column._column is column:
+                break
+        return (wrapper.get_tooltip(iter, wrapper_column), rect)
+
+class VariableHeightTableViewDelegate(TableViewDelegate):
+    def tableView_heightOfRow_(self, table_view, row):
+        model = table_view.dataSource().model
+        iter = model.iter_for_row(table_view, row)
+        if iter is None:
+            return 12
+        return calc_row_height(table_view, model[iter])
+
+
+# TableViewCommon is a hack to do a Mixin class.  We want the same behaviour
+# for our table views and our outline views.  Normally we would use a Mixin,
+# but that doesn't work with pyobjc.  Instead we define the common code in
+# TableViewCommon, then copy it into MiroTableView and MiroOutlineView
+
+class TableViewCommon(object):
+    def init(self):
+        self = super(self.__class__, self).init()
+        self.hotspot_tracker = None
+        self._tracking_rects = []
+        self.hover_info = None
+        self.column_index_map = {}
+        self.setFocusRingType_(NSFocusRingTypeNone)
+        self.handled_last_mouse_down = False
+        self.gradientHighlight = False
+        self.tracking_area = None
+        self.group_lines_enabled = False
+        self.group_line_width = 1
+        self.group_line_color = (0, 0, 0, 1.0)
+        # we handle cell spacing manually
+        self.setIntercellSpacing_(NSSize(0, 0))
+        self.column_spacing = 3
+        self.row_spacing = 2
+        return self
+
+    def updateTrackingAreas(self):
+        # remove existing tracking area if needed
+        if self.tracking_area:
+            self.removeTrackingArea_(self.tracking_area)
+
+        # create a new tracking area for the entire view.  This allows us to
+        # get mouseMoved events whenever the mouse is inside our view.
+        self.tracking_area = NSTrackingArea.alloc()
+        self.tracking_area.initWithRect_options_owner_userInfo_(
+                self.visibleRect(),
+                NSTrackingMouseEnteredAndExited | NSTrackingMouseMoved |
+                NSTrackingActiveInKeyWindow,
+                self,
+                nil)
+        self.addTrackingArea_(self.tracking_area)
+
+    def addTableColumn_(self, column):
+        index = len(self.tableColumns())
+        column.set_index(index)
+        self.column_index_map[column._column] = index
+        self.SuperClass.addTableColumn_(self, column._column)
+
+    def removeTableColumn_(self, column):
+        self.SuperClass.removeTableColumn_(self, column)
+        removed = self.column_index_map.pop(column)
+        for key, index in self.column_index_map.items():
+            if index > removed:
+                self.column_index_map[key] -= 1
+
+    def moveColumn_toColumn_(self, src, dest):
+        # Need to switch the TableColumn objects too
+        columns = wrappermap.wrapper(self).columns
+        columns[src], columns[dest] = columns[dest], columns[src]
+        for index, column in enumerate(columns):
+            column.set_index(index)
+        self.SuperClass.moveColumn_toColumn_(self, src, dest)
+
+    def highlightSelectionInClipRect_(self, rect):
+        if wrappermap.wrapper(self).draws_selection:
+            if not self.gradientHighlight:
+                return self.SuperClass.highlightSelectionInClipRect_(self,
+                        rect)
+            context = NSGraphicsContext.currentContext()
+            focused = self.isDescendantOf_(self.window().firstResponder())
+            for row in tablemodel.list_from_nsindexset(self.selectedRowIndexes()):
+                self.drawBackgroundGradient(context, focused, row)
+
+    def setFrameSize_(self, size):
+        if size.height == 0:
+            size.height = 4
+        self.SuperClass.setFrameSize_(self, size)
+
+    def drawBackgroundGradient(self, context, focused, row):
+        widget = wrappermap.wrapper(self)
+        window = widget.get_window()
+        if window and window.is_active():
+            if focused:
+                start_color = (0.588, 0.717, 0.843)
+                end_color = (0.416, 0.568, 0.713)
+                top_line_color = (0.416, 0.569, 0.714, 1.0)
+                bottom_line_color = (0.416, 0.569, 0.714, 1.0)
+            else:
+                start_color = (168 / 255.0, 188 / 255.0, 208 / 255.0)
+                end_color = (129 / 255.0, 152 / 255.0, 176 / 255.0)
+                top_line_color = (129 / 255.0, 152 / 255.0, 175 / 255.0, 1.0)
+                bottom_line_color = (0.416, 0.569, 0.714, 1.0)
+        else:
+            start_color = (0.675, 0.722, 0.765)
+            end_color = (0.592, 0.659, 0.710)
+            top_line_color = (0.596, 0.635, 0.671, 1.0)
+            bottom_line_color = (0.522, 0.576, 0.620, 1.0)
+
+        rect = self.rectOfRow_(row)
+        top = NSMakeRect(rect.origin.x, rect.origin.y, rect.size.width, 1)
+        context.saveGraphicsState()
+        # draw the top line
+        NSColor.colorWithDeviceRed_green_blue_alpha_(*top_line_color).set()
+        NSRectFill(top)
+        bottom = NSMakeRect(rect.origin.x, rect.origin.y + rect.size.height - 2,
+                            rect.size.width, 1)
+        NSColor.colorWithDeviceRed_green_blue_alpha_(*bottom_line_color).set()
+        NSRectFill(bottom)
+        highlight = NSMakeRect(rect.origin.x, rect.origin.y + rect.size.height - 1,
+                               rect.size.width, 1)
+        NSColor.colorWithDeviceRed_green_blue_alpha_(0.918, 0.925, 0.941, 1.0).set()
+        NSRectFill(highlight)
+
+        # draw the gradient
+        rect.origin.y += 1
+        rect.size.height -= 3
+        NSRectClip(rect)
+        gradient = Gradient(rect.origin.x, rect.origin.y,
+                rect.origin.x, rect.origin.y + rect.size.height)
+        gradient.set_start_color(start_color)
+        gradient.set_end_color(end_color)
+        gradient.draw()
+        context.restoreGraphicsState()
+
+    def drawBackgroundInClipRect_(self, clip_rect):
+        # save our graphics state, since we are about to modify the clip path
+        graphics_context = NSGraphicsContext.currentContext()
+        graphics_context.saveGraphicsState()
+        # create a NSBezierPath that contains the rects of the columns with
+        # DRAW_BACKGROUND True.
+        clip_path = NSBezierPath.bezierPath()
+        number_of_columns = len(self.tableColumns())
+        for col_index in iter_range(self.columnsInRect_(clip_rect)):
+            column = wrappermap.wrapper(self.tableColumns()[col_index])
+            column_rect = None
+            if column.renderer.DRAW_BACKGROUND:
+                # We should draw the background for this column, add it's rect
+                # to our clip rect.
+                column_rect = self.rectOfColumn_(col_index)
+                clip_path.appendBezierPathWithRect_(column_rect)
+            else:
+                # We shouldn't draw the background for this column.  Don't add
+                # anything to the clip rect, but do draw the area before the
+                # first row and after the last row.
+                self.drawBackgroundOutsideContent_clipRect_(col_index,
+                        clip_rect)
+            if col_index == number_of_columns - 1: # last column
+                if not column_rect:
+                    column_rect = self.rectOfColumn_(col_index)
+                column_right = column_rect.origin.x + column_rect.size.width
+                clip_right = clip_rect.origin.x + clip_rect.size.width
+                if column_right < clip_right:
+                    # there's space to the right, so add that to the clip_rect
+                    remaining = clip_right - column_right
+                    left_rect = NSMakeRect(column_right, clip_rect.origin.y,
+                                           remaining, clip_rect.size.height)
+                    clip_path.appendBezierPathWithRect_(left_rect)
+        # clip to that path
+        clip_path.addClip()
+        # do the default drawing
+        self.SuperClass.drawBackgroundInClipRect_(self, clip_rect)
+        # restore graphics state
+        graphics_context.restoreGraphicsState()
+
+    def drawBackgroundOutsideContent_clipRect_(self, index, clip_rect):
+        """Draw our background outside the rows with content
+
+        We call this for cells with DRAW_BACKGROUND set to False.  For those,
+        we let the cell draw their own background, but we still need to draw
+        the background before the first cell and after the last cell.
+        """
+
+        self.backgroundColor().set()
+
+        total_rect = NSIntersectionRect(self.rectOfColumn_(index), clip_rect)
+
+        if self.numberOfRows() == 0:
+            # if no rows are selected, draw the background over everything
+            NSRectFill(total_rect)
+            return
+
+        # fill the area above the first row
+        first_row_rect = self.rectOfRow_(0)
+        if first_row_rect.origin.y > total_rect.origin.y:
+            height = first_row_rect.origin.y - total_rect.origin.y
+            NSRectFill(NSMakeRect(total_rect.origin.x, total_rect.origin.y,
+                    total_rect.size.width, height))
+
+        # fill the area below the last row
+        last_row_rect = self.rectOfRow_(self.numberOfRows()-1)
+        if NSMaxY(last_row_rect) < NSMaxY(total_rect):
+            y = NSMaxY(last_row_rect) + 1
+            height = NSMaxY(total_rect) - NSMaxY(last_row_rect)
+            NSRectFill(NSMakeRect(total_rect.origin.x, y,
+                    total_rect.size.width, height))
+
+    def drawRow_clipRect_(self, row, clip_rect):
+        self.SuperClass.drawRow_clipRect_(self, row, clip_rect)
+        if self.group_lines_enabled:
+            self.drawGroupLine_(row)
+
+    def drawGroupLine_(self, row):
+        infolist = wrappermap.wrapper(self).model
+        if (not isinstance(infolist, tablemodel.InfoListModel) or
+                infolist.get_grouping() is None):
+            return
+
+        info, attrs, group_info = infolist[row]
+        if group_info[0] == group_info[1] - 1:
+            rect = self.rectOfRow_(row)
+            rect.origin.y = NSMaxY(rect) - self.group_line_width
+            rect.size.height = self.group_line_width
+            NSColor.colorWithDeviceRed_green_blue_alpha_(
+                    *self.group_line_color).set()
+            NSRectFill(rect)
+
+    def canDragRowsWithIndexes_atPoint_(self, indexes, point):
+        return YES
+
+    def draggingSourceOperationMaskForLocal_(self, local):
+        drag_source = wrappermap.wrapper(self).drag_source
+        if drag_source and local:
+            return drag_source.allowed_actions()
+        return NSDragOperationNone
+
+    def mouseMoved_(self, event):
+        location = self.convertPoint_fromView_(event.locationInWindow(), nil)
+        row = self.rowAtPoint_(location)
+        column = self.columnAtPoint_(location)
+        if (self.hover_info is not None and self.hover_info != (row, column)):
+            # left a cell, redraw it the old one
+            rect = self.frameOfCellAtColumn_row_(self.hover_info[1],
+                    self.hover_info[0])
+            self.setNeedsDisplayInRect_(rect)
+        if row == -1 or column == -1:
+            # corner case: we got a mouseMoved_ event, but the pointer is
+            # outside the view
+            self.hover_pos = self.hover_info = None
+            return
+        # queue a redraw on the cell currently hovered over
+        rect = self.frameOfCellAtColumn_row_(column, row)
+        self.setNeedsDisplayInRect_(rect)
+        # recalculate hover_pos and hover_info
+        self.hover_pos = (location[0] - rect[0][0],
+                location[0] - rect[0][1])
+        self.hover_info = (row, column)
+
+    def mouseExited_(self, event):
+        if self.hover_info:
+            # mouse left our window, unset hover and redraw the cell that the
+            # mouse was in
+            rect = self.frameOfCellAtColumn_row_(self.hover_info[1],
+                    self.hover_info[0])
+            self.setNeedsDisplayInRect_(rect)
+            self.hover_pos = self.hover_info = None
+
+    def get_hover(self, row, column):
+        if self.hover_info == (row, column):
+            return self.hover_pos
+        else:
+            return None
+
+    def mouseDown_(self, event):
+        if event.modifierFlags() & NSControlKeyMask:
+            self.handleContextMenu_(event)
+            self.handled_last_mouse_down = True
+            return
+
+        point = self.convertPoint_fromView_(event.locationInWindow(), nil)
+
+        if event.clickCount() == 2:
+            if self.handled_last_mouse_down:
+                return
+            wrapper = wrappermap.wrapper(self)
+            row = self.rowAtPoint_(point)
+            if (row != -1 and self.point_should_click(point, row)):
+                iter = wrapper.model.iter_for_row(self, row)
+                wrapper.emit('row-activated', iter)
+            return
+
+        # Like clickCount() == 2 but keep running so we can get to run the
+        # hotspot tracker et al.
+        if event.clickCount() == 1:
+            wrapper = wrappermap.wrapper(self)
+            row = self.rowAtPoint_(point)
+            if (row != -1 and self.point_should_click(point, row)):
+
+                iter = wrapper.model.iter_for_row(self, row)
+                wrapper.emit('row-clicked', iter)
+
+        hotspot_tracker = HotspotTracker(self, point)
+        if hotspot_tracker.hit:
+            self.hotspot_tracker = hotspot_tracker
+            self.hotspot_tracker.redraw_cell()
+            self.handled_last_mouse_down = True
+            if hotspot_tracker.is_for_context_menu():
+                self.popup_context_menu(self.hotspot_tracker.row, event)
+                # once we're out of that call, we know the context menu is
+                # gone
+                hotspot_tracker.redraw_cell()
+                self.hotspot_tracker = None
+        else:
+            self.handled_last_mouse_down = False
+            self.SuperClass.mouseDown_(self, event)
+
+    def point_should_click(self, point, row):
+        """Should a click on a point result in a row-clicked signal?
+
+        Subclasses can override if not every point should result in a click.
+        """
+        return True
+
+    def rightMouseDown_(self, event):
+        self.handleContextMenu_(event)
+
+    def handleContextMenu_(self, event):
+        self.window().makeFirstResponder_(self)
+        point = self.convertPoint_fromView_(event.locationInWindow(), nil)
+        column = self.columnAtPoint_(point)
+        row = self.rowAtPoint_(point)
+        if self.group_lines_enabled and column == 0:
+            self.selectAllItemsInGroupForRow_(row)
+        self.popup_context_menu(row, event)
+
+    def selectAllItemsInGroupForRow_(self, row):
+        wrapper = wrappermap.wrapper(self)
+        infolist = wrapper.model
+        if (not isinstance(infolist, tablemodel.InfoListModel) or
+                infolist.get_grouping() is None):
+            return
+
+        info, attrs, group_info = infolist[row]
+        select_range = NSMakeRange(row - group_info[0], group_info[1])
+        index_set = NSIndexSet.indexSetWithIndexesInRange_(select_range)
+        self.selectRowIndexes_byExtendingSelection_(index_set, NO)
+
+    def popup_context_menu(self, row, event):
+        selection = self.selectedRowIndexes()
+        if row != -1 and not selection.containsIndex_(row):
+            index_set = NSIndexSet.alloc().initWithIndex_(row)
+            self.selectRowIndexes_byExtendingSelection_(index_set, NO)
+        wrapper = wrappermap.wrapper(self)
+        if wrapper.context_menu_callback is not None:
+            menu_items = wrapper.context_menu_callback(wrapper)
+            menu = osxmenus.make_context_menu(menu_items)
+            NSMenu.popUpContextMenu_withEvent_forView_(menu, event, self)
+
+    def mouseDragged_(self, event):
+        if self.hotspot_tracker is not None:
+            point = self.convertPoint_fromView_(event.locationInWindow(), nil)
+            self.hotspot_tracker.update_position(point)
+            self.hotspot_tracker.update_hit()
+        else:
+            self.SuperClass.mouseDragged_(self, event)
+
+    def mouseUp_(self, event):
+        if self.hotspot_tracker is not None:
+            point = self.convertPoint_fromView_(event.locationInWindow(), nil)
+            self.hotspot_tracker.update_position(point)
+            self.hotspot_tracker.update_hit()
+            if self.hotspot_tracker.hit:
+                wrappermap.wrapper(self).send_hotspot_clicked()
+            if self.hotspot_tracker:
+                self.hotspot_tracker.redraw_cell()
+                self.hotspot_tracker = None
+        else:
+            self.SuperClass.mouseUp_(self, event)
+
+    def keyDown_(self, event):
+        mods = osxmenus.translate_event_modifiers(event)
+        if event.charactersIgnoringModifiers() == ' ' and len(mods) == 0:
+            # handle spacebar with no modifiers by sending the row-activated
+            # signal
+            wrapper = wrappermap.wrapper(self)
+            row = self.selectedRow()
+            if row >= 0:
+                iter = wrapper.model.iter_for_row(self, row)
+                wrapper.emit('row-activated', iter)
+        else:
+            self.SuperClass.keyDown_(self, event)
+
+class TableColumn(signals.SignalEmitter):
+    def __init__(self, title, renderer, header=None, **attrs):
+        signals.SignalEmitter.__init__(self)
+        self.create_signal('clicked')
+        self._column = MiroTableColumn.alloc().initWithIdentifier_(title)
+        self._column.set_attrs(attrs)
+        wrappermap.add(self._column, self)
+        header_cell = MiroTableHeaderCell.alloc().init()
+        self.custom_header = False
+        if header:
+            header_cell.set_widget(header)
+            self.custom_header = True
+        self._column.setHeaderCell_(header_cell)
+        self._column.headerCell().setStringValue_(title)
+        self._column.setEditable_(NO)
+        self._column.setResizingMask_(NSTableColumnNoResizing)
+        self.renderer = renderer
+        self.sort_order_ascending = True
+        self.sort_indicator_visible = False
+        self.do_horizontal_padding = True
+        self.min_width = self.max_width = None
+        renderer.setDataCell_(self._column)
+
+    def set_do_horizontal_padding(self, horizontal_padding):
+        self.do_horizontal_padding = horizontal_padding
+
+    def set_right_aligned(self, right_aligned):
+        if right_aligned:
+            self._column.headerCell().setAlignment_(NSRightTextAlignment)
+        else:
+            self._column.headerCell().setAlignment_(NSLeftTextAlignment)
+
+    def set_min_width(self, width):
+        self.min_width = width
+
+    def set_max_width(self, width):
+        self.max_width = width
+
+    def set_width(self, width):
+        self._column.setWidth_(width)
+
+    def get_width(self):
+        return self._column.width()
+
+    def set_resizable(self, resizable):
+        mask = 0
+        if resizable:
+            mask |= NSTableColumnUserResizingMask
+        self._column.setResizingMask_(mask)
+
+    def set_sort_indicator_visible(self, visible):
+        self.sort_indicator_visible = visible
+        self._column.tableView().headerView().setNeedsDisplay_(True)
+
+    def get_sort_indicator_visible(self):
+        return self.sort_indicator_visible
+
+    def set_sort_order(self, ascending):
+        self.sort_order_ascending = ascending
+        self._column.tableView().headerView().setNeedsDisplay_(True)
+
+    def get_sort_order_ascending(self):
+        return self.sort_order_ascending
+
+    def set_index(self, index):
+        self.index = index
+        self.renderer.set_index(index)
+
+class MiroTableColumn(NSTableColumn):
+    def set_attrs(self, attrs):
+        self._attrs = attrs
+
+    def attrs(self):
+        return self._attrs
+
+class MiroTableView(NSTableView):
+    SuperClass = NSTableView
+    for name, value in TableViewCommon.__dict__.items():
+        locals()[name] = value
+
+class MiroTableHeaderView(NSTableHeaderView):
+    def initWithFrame_(self, frame):
+        # frame is not used
+        self = super(MiroTableHeaderView, self).initWithFrame_(frame)
+        self.selected = None
+        self.custom_header = False
+        return self
+
+    def drawRect_(self, rect):
+        wrapper = wrappermap.wrapper(self.tableView())
+        if self.selected:
+            self.selected.set_selected(False)
+        for column in wrapper.columns:
+            if column.sort_indicator_visible:
+                self.selected = column._column.headerCell()
+                self.selected.set_selected(True)
+                self.selected.set_ascending(column.sort_order_ascending)
+                break
+        NSTableHeaderView.drawRect_(self, rect)
+        if self.custom_header:
+            NSGraphicsContext.currentContext().saveGraphicsState()
+            # Draw the separator between the header and the contents.
+            context = DrawingContext(self, rect, rect)
+            context.set_line_width(1)
+            context.set_color((2 / 255.0, 2 / 255.0, 2 / 255.0))
+            context.move_to(0, context.height - 0.5)
+            context.rel_line_to(context.width, 0)
+            context.stroke()
+            NSGraphicsContext.currentContext().restoreGraphicsState()
+
+class MiroTableHeaderCell(NSTableHeaderCell):
+    def init(self):
+        self = super(MiroTableHeaderCell, self).init()
+        self.layout_manager = LayoutManager()
+        self.button = None
+        return self
+
+    def set_selected(self, selected):
+        self.button._enabled = selected
+
+    def set_ascending(self, ascending):
+        self.button._ascending = ascending
+
+    def set_widget(self, widget):
+        self.button = widget
+
+    def drawWithFrame_inView_(self, frame, view):
+        if self.button is None:
+            # use the default behavior when set_widget hasn't been called
+            return NSTableHeaderCell.drawWithFrame_inView_(self, frame, view)
+
+        NSGraphicsContext.currentContext().saveGraphicsState()
+        drawing_rect = NSMakeRect(frame.origin.x, frame.origin.y,
+                       frame.size.width, frame.size.height)
+        context = DrawingContext(view, drawing_rect, drawing_rect)
+        context.style = self.make_drawing_style(frame, view)
+        self.layout_manager.reset()
+        columns = wrappermap.wrapper(view.tableView()).columns
+        header_cells = [c._column.headerCell() for c in columns]
+        background_only = not self in header_cells
+        self.button.draw(context, self.layout_manager, background_only)
+        NSGraphicsContext.currentContext().restoreGraphicsState()
+
+    def make_drawing_style(self, frame, view):
+        text_color = None
+        if (self.isHighlighted() and frame is not None and
+                (view.isDescendantOf_(view.window().firstResponder()) or
+                    view.gradientHighlight)):
+            text_color = NSColor.whiteColor()
+        return DrawingStyle(text_color=text_color)
+
+class CocoaSelectionOwnerMixin(SelectionOwnerMixin):
+    """Cocoa-specific methods for selection management.
+
+    This subclass should not define any behavior. Methods that cannot be
+    completed in this widget state should raise WidgetActionError.
+    """
+
+    def _set_allow_multiple_select(self, allow):
+        self.tableview.setAllowsMultipleSelection_(allow)
+
+    def _get_allow_multiple_select(self):
+        return self.tableview.allowsMultipleSelection()
+
+    def _get_selected_iters(self):
+        selection = self.tableview.selectedRowIndexes()
+        selrows = tablemodel.list_from_nsindexset(selection)
+        return [self.model.iter_for_row(self.tableview, row) for row in selrows]
+
+    def _get_selected_iter(self):
+        row = self.tableview.selectedRow()
+        if row == -1:
+            return None
+        return self.model.iter_for_row(self.tableview, row)
+
+    def _get_selected_rows(self):
+        return [self.model[i] for i in self._get_selected_iters()]
+
+    @property
+    def num_rows_selected(self):
+        return self.tableview.numberOfSelectedRows()
+
+    def _is_selected(self, iter_):
+        row = self.row_of_iter(iter_)
+        return self.tableview.isRowSelected_(row)
+
+    def _select(self, iter_):
+        row = self.row_of_iter(iter_)
+        index_set = NSIndexSet.alloc().initWithIndex_(row)
+        self.tableview.selectRowIndexes_byExtendingSelection_(index_set, YES)
+
+    def _unselect(self, iter_):
+        self.tableview.deselectRow_(self.row_of_iter(iter_))
+
+    def _unselect_all(self):
+        self.tableview.deselectAll_(nil)
+
+    def _iter_to_string(self, iter_):
+        return unicode(self.model.row_of_iter(self.tableview, iter_))
+
+    def _iter_from_string(self, row):
+        return self.model.iter_for_row(self.tableview, int(row))
+
+class CocoaScrollbarOwnerMixin(ScrollbarOwnerMixin):
+    """Manages a TableView's scroll position."""
+    def __init__(self):
+        ScrollbarOwnerMixin.__init__(self, _work_around_17153=True)
+        self.connect('place-in-scroller', self.on_place_in_scroller)
+        self.scroll_position = (0, 0)
+        self.clipview_notifications = None
+        self._position_set = False
+
+    def _set_scroll_position(self, scroll_to):
+        """Restore a saved scroll position."""
+        self.scroll_position = scroll_to
+        try:
+            scroller = self._scroller
+        except errors.WidgetNotReadyError:
+            return
+        self._position_set = True
+        clipview = scroller.contentView()
+        if not self.clipview_notifications:
+            self.clipview_notifications = NotificationForwarder.create(clipview)
+            # NOTE: intentional changes are BoundsChanged; bad changes are
+            # FrameChanged
+            clipview.setPostsFrameChangedNotifications_(YES)
+            self.clipview_notifications.connect(self.on_scroll_changed,
+                'NSViewFrameDidChangeNotification')
+        # NOTE: scrollPoint_ just scrolls the point into view; we want to
+        # scroll the view so that the point becomes the origin
+        size = self.tableview.visibleRect().size
+        size = (size.width, size.height)
+        rect = NSMakeRect(scroll_to[0], scroll_to[1], size[0], size[1])
+        self.tableview.scrollRectToVisible_(rect)
+
+    def on_place_in_scroller(self, scroller):
+        # workaround for 17153.1
+        if not self._position_set:
+            self._set_scroll_position(self.scroll_position)
+
+    @property
+    def _manually_scrolled(self):
+        """Return whether the view has been scrolled explicitly by the user
+        since the last time it was set automatically. Ignores X coords.
+        """
+        auto_y = self.scroll_position[1]
+        real_y = self.get_scroll_position()[1]
+        return abs(auto_y - real_y) > 5
+
+    def _get_item_area(self, iter_):
+        rect = self.tableview.rectOfRow_(self.row_of_iter(iter_))
+        return NSRectToRect(rect)
+
+    def _get_visible_area(self):
+        return NSRectToRect(self._scroller.contentView().documentVisibleRect())
+
+    def _get_scroll_position(self):
+        point = self._scroller.contentView().documentVisibleRect().origin
+        return NSPointToPoint(point)
+
+    def on_scroll_changed(self, notification):
+        # we get this notification when the scroll position has been reset (when
+        # it should not have been); put it back
+        self.set_scroll_position(self.scroll_position)
+        # this notification also serves as the Cocoa equivalent to
+        # on_scroll_range_changed, which tells super when we may be ready to
+        # scroll to an iter
+        self.emit('scroll-range-changed')
+
+    def set_scroller(self, scroller):
+        """For GTK; Cocoa tableview knows its enclosingScrollView"""
+
+    @property
+    def _scroller(self):
+        """Return an NSScrollView or raise WidgetNotReadyError"""
+        scroller = self.tableview.enclosingScrollView()
+        if not scroller:
+            raise errors.WidgetNotReadyError('enclosingScrollView')
+        return scroller
+
+class SorterPadding(NSView):
+    # Why is this a Mac only widget?  Because the wrappermap mechanism requires
+    # us to layout the widgets (so that we may call back to the portable API
+    # hooks of the widget.  Since we only set the view component, this fake
+    # widget is never placed so the wrappermap mechanism fails to work.
+    #
+    # So far, this is okay because only the Mac uses custom headers.
+    def init(self):
+        self = super(SorterPadding, self).init()
+        image = Image(resources.path('images/headertoolbar.png'))
+        self.image = ImageSurface(image)
+        return self
+
+    def isFlipped(self):
+        return YES
+
+    def drawRect_(self, rect):
+        context = DrawingContext(self, self.bounds(), rect)
+        context.style = DrawingStyle()
+        self.image.draw(context, 0, 0, context.width, context.height)
+        # XXX this color doesn't take into account enable/disabled state
+        # of the sorting widgets.
+        edge = 72.0 / 255
+        context.set_color((edge, edge, edge))
+        context.set_line_width(1)
+        context.move_to(0.5, 0)
+        context.rel_line_to(0, context.height)
+        context.stroke()
+
+class TableView(CocoaSelectionOwnerMixin, CocoaScrollbarOwnerMixin, Widget):
+    """Displays data as a tabular list.  TableView follows the GTK TreeView
+    widget fairly closely.
+    """
+
+    CREATES_VIEW = False
+    # Bit of a hack.  We create several views.  By setting CREATES_VIEW to
+    # False, we get to position the views manually.
+
+    draws_selection = True
+
+    def __init__(self, model, custom_headers=False):
+        Widget.__init__(self)
+        CocoaSelectionOwnerMixin.__init__(self)
+        CocoaScrollbarOwnerMixin.__init__(self)
+        self.create_signal('hotspot-clicked')
+        self.create_signal('row-clicked')
+        self.create_signal('row-activated')
+        self.create_signal('reallocate-columns')
+        self.model = model
+        self.columns = []
+        self.drag_source = self.drag_dest = None
+        self.context_menu_callback = None
+        self.tableview = MiroTableView.alloc().init()
+        self.data_source = tablemodel.MiroTableViewDataSource.alloc()
+        types = (tablemodel.MIRO_DND_ITEM_LOCAL,)
+        self.tableview.registerForDraggedTypes_(types)
+        self.view = self.tableview
+        self.data_source.initWithModel_(self.model)
+        self.tableview.setDataSource_(self.data_source)
+        self.tableview.setVerticalMotionCanBeginDrag_(YES)
+        self.set_columns_draggable(False)
+        self.set_auto_resizes(False)
+        self.row_height_set = False
+        self.set_fixed_height(False)
+        self.auto_resizing = False
+        self.header_view = MiroTableHeaderView.alloc().initWithFrame_(
+            NSMakeRect(0, 0, 0, 0))
+        self.tableview.setCornerView_(None)
+        self.custom_header = False
+        self.header_height = HEADER_HEIGHT
+        self.set_show_headers(True)
+        self.notifications = NotificationForwarder.create(self.tableview)
+        self.model_signal_ids = [
+            self.model.connect_weak('row-changed', self.on_row_change),
+            self.model.connect_weak('structure-will-change',
+                    self.on_model_structure_change),
+        ]
+        self.iters_to_update = []
+        self.height_changed = self.reload_needed = False
+        self.old_selection = None
+        self._resizing = False
+        if custom_headers:
+            self._enable_custom_headers()
+
+    def unset_model(self):
+        for signal_id in self.model_signal_ids:
+            self.model.disconnect(signal_id)
+        self.model = None
+        self.tableview.setDataSource_(None)
+        self.data_source = None
+
+    def _enable_custom_headers(self):
+        self.custom_header = True
+        self.header_height = CUSTOM_HEADER_HEIGHT
+        self.header_view.custom_header = True
+        self.tableview.setCornerView_(SorterPadding.alloc().init())
+
+    def enable_album_view_focus_hack(self):
+        # this only matters on GTK
+        pass
+
+    def focus(self):
+        if self.tableview.window() is not None:
+            self.tableview.window().makeFirstResponder_(self.tableview)
+
+    def send_hotspot_clicked(self):
+        tracker = self.tableview.hotspot_tracker
+        self.emit('hotspot-clicked', tracker.name, tracker.iter)
+
+    def on_row_change(self, model, iter):
+        self.iters_to_update.append(iter)
+        if not self.fixed_height:
+            self.height_changed = True
+        if self.tableview.hotspot_tracker is not None:
+            self.tableview.hotspot_tracker.update_hit()
+
+    def on_model_structure_change(self, model):
+        self.will_need_reload()
+        self.cancel_hotspot_track()
+
+    def will_need_reload(self):
+        if not self.reload_needed:
+            self.reload_needed = True
+            self.old_selection = self._get_selected_rows()
+
+    def cancel_hotspot_track(self):
+        if self.tableview.hotspot_tracker is not None:
+            self.tableview.hotspot_tracker.redraw_cell()
+            self.tableview.hotspot_tracker = None
+
+    def on_expanded(self, notification):
+        self.invalidate_size_request()
+        item = notification.userInfo()['NSObject']
+        iter_ = self.model.iter_for_item[item]
+        self.emit('row-expanded', iter_, self.model.get_path(iter_))
+
+    def on_collapsed(self, notification):
+        self.invalidate_size_request()
+        item = notification.userInfo()['NSObject']
+        iter_ = self.model.iter_for_item[item]
+        self.emit('row-collapsed', iter_, self.model.get_path(iter_))
+
+    def on_column_resize(self, notification):
+        if self.auto_resizing or self._resizing:
+            return
+        self._resizing = True
+        try:
+            column = notification.userInfo()['NSTableColumn']
+            label = column.headerCell().stringValue()
+            self.emit('reallocate-columns', {label: column.width()})
+        finally:
+            self._resizing = False
+
+    def is_tree(self):
+        return isinstance(self.model, tablemodel.TreeTableModel)
+
+    def set_row_expanded(self, iter, expanded):
+        """Expand or collapse the specified row. Succeeds or raises
+        WidgetActionError.
+        """
+        item = iter.value()
+        if expanded:
+            self.tableview.expandItem_(item)
+        else:
+            self.tableview.collapseItem_(item)
+        if self.tableview.isItemExpanded_(item) != expanded:
+            raise errors.WidgetActionError(
+                "cannot expand iter. expandable: %r" % (
+                    self.tableview.isExpandable_(item),))
+        self.invalidate_size_request()
+
+    def is_row_expanded(self, iter):
+        return self.tableview.isItemExpanded_(iter.value())
+
+    def calc_size_request(self):
+        self.tableview.tile()
+        height = self.tableview.frame().size.height
+        if self._show_headers:
+            height += self.header_height
+        return self.calc_width(), height
+
+    def viewport_repositioned(self):
+        self._do_layout()
+
+    def viewport_created(self):
+        wrappermap.add(self.tableview, self)
+        self._do_layout()
+        self._add_views()
+        self.notifications.connect(self.on_selection_changed,
+                                   'NSTableViewSelectionDidChangeNotification')
+        self.notifications.connect(self.on_column_resize,
+                                   'NSTableViewColumnDidResizeNotification')
+        # scroll has been unset
+        self._position_set = False
+
+    def remove_viewport(self):
+        if self.viewport is not None:
+            self._remove_views()
+            wrappermap.remove(self.tableview)
+            self.notifications.disconnect()
+            self.viewport = None
+        if self.clipview_notifications:
+            self.clipview_notifications.disconnect()
+            self.clipview_notifications = None
+
+    def _should_place_header_view(self):
+        return self._show_headers and not self.parent_is_scroller
+
+    def _add_views(self):
+        self.viewport.view.addSubview_(self.tableview)
+        if self._should_place_header_view():
+            self.viewport.view.addSubview_(self.header_view)
+
+    def _remove_views(self):
+        self.tableview.removeFromSuperview()
+        self.header_view.removeFromSuperview()
+
+    def _do_layout(self):
+        x = self.viewport.placement.origin.x
+        y = self.viewport.placement.origin.y
+        width = self.viewport.get_width()
+        height = self.viewport.get_height()
+        if self._should_place_header_view():
+            self.header_view.setFrame_(NSMakeRect(x, y,
+                width, self.header_height))
+            self.tableview.setFrame_(NSMakeRect(x, y + self.header_height,
+                width, height - self.header_height))
+        else:
+            self.header_view.setFrame_(NSMakeRect(x, y,
+                width, self.header_height))
+            self.tableview.setFrame_(NSMakeRect(x, y, width, height))
+
+        if self.auto_resize:
+            self.auto_resizing = True
+            # ListView sizes itself in do_size_allocated;
+            # this is necessary for tablist and StandardView
+            columns = self.tableview.tableColumns()
+            if len(columns) == 1:
+                columns[0].setWidth_(self.viewport.area().size.width)
+            self.auto_resizing = False
+        self.queue_redraw()
+
+    def calc_width(self):
+        if self.column_count() == 0:
+            return 0
+        width = 0
+        columns = self.tableview.tableColumns()
+        if self.auto_resize:
+            # Table auto-resizes, we can shrink to min-width for each column
+            width = sum(column.minWidth() for column in columns)
+            width += self.tableview.column_spacing * self.column_count()
+        else:
+            # Table doesn't auto-resize, the columns can't get smaller than
+            # their current width
+            width = sum(column.width() for column in columns)
+        return width
+
+    def start_bulk_change(self):
+        # stop our model from emitting signals, which is slow if we're
+        # adding/removing/changing a bunch of rows.  Instead, just reload the
+        # model afterwards.
+        self.will_need_reload()
+        self.cancel_hotspot_track()
+        self.model.freeze_signals()
+
+    def model_changed(self):
+        if not self.row_height_set and self.fixed_height:
+            self.try_to_set_row_height()
+        self.model.thaw_signals()
+        size_changed = False
+        if self.reload_needed:
+            self.tableview.reloadData()
+            new_selection = self._get_selected_rows()
+            if new_selection != self.old_selection:
+                self.on_selection_changed(self.tableview)
+            self.old_selection = None
+            size_changed = True
+        elif self.iters_to_update:
+            if self.fixed_height or not self.height_changed:
+                # our rows don't change height, just update cell areas
+                if self.is_tree():
+                    for iter in self.iters_to_update:
+                        self.tableview.reloadItem_(iter.value())
+                else:
+                    for iter in self.iters_to_update:
+                        row = self.row_of_iter(iter)
+                        rect = self.tableview.rectOfRow_(row)
+                        self.tableview.setNeedsDisplayInRect_(rect)
+            else:
+                # our rows can change height inform Cocoa that their heights
+                # might have changed (this will redraw them)
+                index_set = NSMutableIndexSet.alloc().init()
+                for iter in self.iters_to_update:
+                    try:
+                        index_set.addIndex_(self.row_of_iter(iter))
+                    except LookupError:
+                        # This happens when the iter's parent is unexpanded,
+                        # just ignore.
+                        pass
+                self.tableview.noteHeightOfRowsWithIndexesChanged_(index_set)
+                size_changed = True
+        else:
+            return
+        if size_changed:
+            self.invalidate_size_request()
+        self.height_changed = self.reload_needed = False
+        self.iters_to_update = []
+
+    def width_for_columns(self, width):
+        """If the table is width pixels big, how much width is available for
+        the table's columns.
+        """
+        # XXX this used to do some calculation with the spacing of each column,
+        # but it doesn't appear like we need it to be that complicated anymore
+        # (see #18273)
+        return width - 2
+
+    def set_column_spacing(self, column_spacing):
+        self.tableview.column_spacing = column_spacing
+
+    def set_row_spacing(self, row_spacing):
+        self.tableview.row_spacing = row_spacing
+
+    def set_alternate_row_backgrounds(self, setting):
+        self.tableview.setUsesAlternatingRowBackgroundColors_(setting)
+
+    def set_grid_lines(self, horizontal, vertical):
+        mask = 0
+        if horizontal:
+            mask |= NSTableViewSolidHorizontalGridLineMask
+        if vertical:
+            mask |= NSTableViewSolidVerticalGridLineMask
+        self.tableview.setGridStyleMask_(mask)
+
+    def set_gradient_highlight(self, setting):
+        self.tableview.gradientHighlight = setting
+
+    def set_group_lines_enabled(self, enabled):
+        self.tableview.group_lines_enabled = enabled
+        self.queue_redraw()
+
+    def set_group_line_style(self, color, width):
+        self.tableview.group_line_color = color + (1.0,)
+        self.tableview.group_line_width = width
+        self.queue_redraw()
+
+    def get_tooltip(self, iter, column):
+        return None
+
+    def add_column(self, column):
+        if not self.custom_header == column.custom_header:
+            raise ValueError('Column header does not match type '
+                             'required by TableView')
+        self.columns.append(column)
+        self.tableview.addTableColumn_(column)
+        self._set_min_max_column_widths(column)
+        # Adding a column means that each row could have a different height.
+        # call noteNumberOfRowsChanged() to have OS X recalculate the heights
+        self.tableview.noteNumberOfRowsChanged()
+        self.invalidate_size_request()
+        self.try_to_set_row_height()
+
+    def _set_min_max_column_widths(self, column):
+        if column.do_horizontal_padding:
+            spacing = self.tableview.column_spacing
+        else:
+            spacing = 0
+        if column.min_width > 0:
+            column._column.setMinWidth_(column.min_width + spacing)
+        if column.max_width > 0:
+            column._column.setMaxWidth_(column.max_width + spacing)
+
+    def column_count(self):
+        return len(self.tableview.tableColumns())
+
+    def remove_column(self, index):
+        column = self.columns.pop(index)
+        self.tableview.removeTableColumn_(column._column)
+        self.invalidate_size_request()
+
+    def get_columns(self):
+        titles = []
+        columns = self.tableview.tableColumns()
+        for column in columns:
+            titles.append(column.headerCell().stringValue())
+        return titles
+
+    def set_background_color(self, (red, green, blue)):
+        color = NSColor.colorWithDeviceRed_green_blue_alpha_(red, green, blue,
+                1.0)
+        self.tableview.setBackgroundColor_(color)
+
+    def set_show_headers(self, show):
+        self._show_headers = show
+        if show:
+            self.tableview.setHeaderView_(self.header_view)
+        else:
+            self.tableview.setHeaderView_(None)
+        if self.viewport is not None:
+            self._remove_views()
+            self._do_layout()
+            self._add_views()
+        self.invalidate_size_request()
+        self.queue_redraw()
+
+    def is_showing_headers(self):
+        return self._show_headers
+
+    def set_search_column(self, model_index):
+        pass
+
+    def try_to_set_row_height(self):
+        if len(self.model) > 0:
+            first_iter = self.model.first_iter()
+            height = calc_row_height(self.tableview, self.model[first_iter])
+            self.tableview.setRowHeight_(height)
+            self.row_height_set = True
+
+    def set_auto_resizes(self, setting):
+        self.auto_resize = setting
+
+    def set_columns_draggable(self, dragable):
+        self.tableview.setAllowsColumnReordering_(dragable)
+
+    def set_fixed_height(self, fixed):
+        if fixed:
+            self.fixed_height = True
+            delegate_class = TableViewDelegate
+            self.row_height_set = False
+            self.try_to_set_row_height()
+        else:
+            self.fixed_height = False
+            delegate_class = VariableHeightTableViewDelegate
+        self.delegate = delegate_class.alloc().init()
+        self.tableview.setDelegate_(self.delegate)
+        self.tableview.reloadData()
+
+    def row_of_iter(self, iter):
+        return self.model.row_of_iter(self.tableview, iter)
+
+    def set_context_menu_callback(self, callback):
+        self.context_menu_callback = callback
+
+    # disable the drag when the cells are constantly updating.  Mac OS X
+    # deals badly with this..
+    def set_volatile(self, volatile):
+        if volatile:
+            self.data_source.setDragSource_(None)
+            self.data_source.setDragDest_(None)
+        else:
+            self.data_source.setDragSource_(self.drag_source)
+            self.data_source.setDragDest_(self.drag_dest)
+
+    def set_drag_source(self, drag_source):
+        self.drag_source = drag_source
+        self.data_source.setDragSource_(drag_source)
+
+    def set_drag_dest(self, drag_dest):
+        self.drag_dest = drag_dest
+        if drag_dest is None:
+            self.data_source.setDragDest_(None)
+        else:
+            types = drag_dest.allowed_types()
+            self.data_source.setDragDest_(drag_dest)
diff --git a/lvc/widgets/osx/utils.py b/lvc/widgets/osx/utils.py
new file mode 100644
index 0000000..c0c2d85
--- /dev/null
+++ b/lvc/widgets/osx/utils.py
@@ -0,0 +1,2 @@
+def filename_to_unicode(filename):
+    return filename.decode('utf8')
diff --git a/lvc/widgets/osx/viewport.py b/lvc/widgets/osx/viewport.py
new file mode 100644
index 0000000..e6564d4
--- /dev/null
+++ b/lvc/widgets/osx/viewport.py
@@ -0,0 +1,101 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".viewport.py -- Viewport classes
+
+A Viewport represents the area where a Widget is located.
+"""
+
+from objc import YES, NO, nil
+from Foundation import *
+
+class Viewport(object):
+    """Used when a widget creates it's own NSView."""
+    def __init__(self, view, initial_frame):
+        self.view = view
+        self.view.setFrame_(initial_frame)
+        self.placement = initial_frame
+
+    def at_position(self, rect):
+        """Check if a viewport is currently positioned at rect."""
+        return self.placement == rect
+
+    def reposition(self, rect):
+        """Move the viewport to a different position."""
+        self.view.setFrame_(rect)
+        self.placement = rect
+
+    def remove(self):
+        self.view.removeFromSuperview()
+
+    def area(self):
+        """Area of our view that is occupied by the viewport."""
+        return NSRect(self.view.bounds().origin, self.placement.size)
+
+    def get_width(self):
+        return self.view.frame().size.width
+
+    def get_height(self):
+        return self.view.frame().size.height
+
+    def queue_redraw(self):
+        opaque_view = self.view.opaqueAncestor()
+        if opaque_view is not None:
+            rect = opaque_view.convertRect_fromView_(self.area(), self.view)
+            opaque_view.setNeedsDisplayInRect_(rect)
+
+    def redraw_now(self):
+        self.view.displayRect_(self.area())
+
+class BorrowedViewport(Viewport):
+    """Used when a widget uses the NSView of one of it's ancestors.  We store
+    the view that we borrow as well as an NSRect specifying where on that view
+    we are placed.
+    """
+    def __init__(self, view, placement):
+        self.view = view
+        self.placement = placement
+
+    def at_position(self, rect):
+        return self.placement == rect
+
+    def reposition(self, rect):
+        self.placement = rect
+
+    def remove(self):
+        pass
+
+    def area(self):
+        return self.placement
+
+    def get_width(self):
+        return self.placement.size.width
+
+    def get_height(self):
+        return self.placement.size.height
diff --git a/lvc/widgets/osx/widgetset.py b/lvc/widgets/osx/widgetset.py
new file mode 100644
index 0000000..1203566
--- /dev/null
+++ b/lvc/widgets/osx/widgetset.py
@@ -0,0 +1,58 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".widgetset -- Contains all the
+platform-specific widgets.  This module doesn't have any actual code in it, it
+just imports the widgets from their actual locations.
+"""
+
+from .const import *
+from .control import (TextEntry, NumberEntry,
+     SecureTextEntry, MultilineTextEntry)
+from .control import Checkbox, Button, OptionMenu, RadioButtonGroup, RadioButton
+from .customcontrol import (CustomButton,
+        ContinuousCustomButton, CustomSlider, DragableCustomButton)
+from .contextmenu import ContextMenu
+from .drawing import DrawingContext, ImageSurface, Gradient
+from .drawingwidgets import DrawingArea, Background
+from .rect import Rect
+from .layout import VBox, HBox, Alignment, Table, Scroller, Expander, TabContainer, DetachedWindowHolder
+from .window import Window, MainWindow, Dialog, FileSaveDialog, FileOpenDialog
+from .window import DirectorySelectDialog, AboutDialog, AlertDialog, PreferencesWindow, DonateWindow, DialogWindow, get_first_time_dialog_coordinates
+from .simple import (Image, ImageDisplay, Label,
+        SolidBackground, ClickableImageButton, AnimatedImageDisplay,
+        ProgressBar, HLine)
+from .tableview import (TableView, TableColumn,
+        CellRenderer, CustomCellRenderer, ImageCellRenderer,
+        CheckboxCellRenderer,
+        CUSTOM_HEADER_HEIGHT)
+from .tablemodel import (TableModel,
+        TreeTableModel)
+from .osxmenus import (MenuBar, Menu, Separator, MenuItem, RadioMenuItem, CheckMenuItem)
+from .base import Widget
diff --git a/lvc/widgets/osx/widgetupdates.py b/lvc/widgets/osx/widgetupdates.py
new file mode 100644
index 0000000..30677c2
--- /dev/null
+++ b/lvc/widgets/osx/widgetupdates.py
@@ -0,0 +1,72 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""widgetupdates.py -- Handle updates to our widgets
+"""
+
+from PyObjCTools import AppHelper
+
+class SizeRequestManager(object):
+    """Helper object to manage size requests
+
+    If something changes in a widget that makes us want to request a new size,
+    we avoid calculating it immediately.  The reason is that the
+    new-size-request will cascade all the way up the widget tree, and then
+    result in our widget being placed.  We don't necessary want all of this
+    action to happen while we are in the middle of handling an event
+    (especially with TableView).  It's also inefficient to calculate things
+    immediately, since we might do something else to invalidate the size
+    request in the current event.
+
+    SizeRequestManager stores which widgets need to have their size
+    recalculated, then calls do_invalidate_size_request() using callAfter
+    """
+
+    def __init__(self):
+        self.widgets_to_request = set()
+        #app.widgetapp.connect("event-processed", self._on_event_processed)
+
+    def add_widget(self, widget):
+        if len(self.widgets_to_request) == 0:
+            AppHelper.callAfter(self._run_requests)
+        self.widgets_to_request.add(widget)
+
+    def _run_requests(self):
+        this_run = self.widgets_to_request
+        self.widgets_to_request = set()
+        for widget in this_run:
+            widget.do_invalidate_size_request()
+
+    def _on_event_processed(self, app):
+        # once we finishing handling an event, process our size requests ASAP
+        # to avoid any potential weirdness.  Note: that we also schedule a
+        # call using callAfter(), often that will do nothing, but it's
+        # possible size requests get scheduled outside of an event
+        while self.widgets_to_request:
+            self._run_requests()
diff --git a/lvc/widgets/osx/window.py b/lvc/widgets/osx/window.py
new file mode 100644
index 0000000..53b1091
--- /dev/null
+++ b/lvc/widgets/osx/window.py
@@ -0,0 +1,896 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".window -- Top-level Window class.  """
+
+import logging
+
+from AppKit import *
+from Foundation import *
+from objc import YES, NO, nil
+from PyObjCTools import AppHelper
+
+from lvc import signals
+from lvc.widgets import widgetconst
+import wrappermap
+import osxmenus
+from .helpers import NotificationForwarder
+from .base import Widget, FlippedView
+from .layout import VBox, HBox, Alignment
+from .control import Button
+from .simple import Label
+from .rect import Rect, NSRectWrapper
+from .utils import filename_to_unicode
+
+# Tracks all windows that haven't been destroyed.  This makes sure there
+# object stay alive as long as the window is alive.
+alive_windows = set()
+
+class MiroResponderInterceptor(NSResponder):
+    """Intercepts cocoa events and gives our wrappers and chance to handle
+    them first.
+    """
+
+    def initWithResponder_(self, responder):
+        """Initialize a MiroResponderInterceptor
+
+        We will give the wrapper for responder a chance to handle the event,
+        then pass it along to responder.
+        """
+        self = super(MiroResponderInterceptor, self).init()
+        self.responder = responder
+        return self
+
+    def keyDown_(self, event):
+        if self.sendKeyDownToWrapper_(event):
+            return # signal handler returned True, stop processing
+
+        # If our responder is the last in the chain, we can stop intercepting
+        if self.responder.nextResponder() is None:
+            self.responder.keyDown_(event)
+            return
+
+        # Here's the tricky part, we want to call keyDown_ on our responder,
+        # but if it doesn't handle the event, then it will pass it along to
+        # it's next responder.  We need to set things up so that we will
+        # intercept that call.
+
+        # Make a new MiroResponderInterceptor whose responder is the next
+        # responder down the chain.
+        next_intercepter = MiroResponderInterceptor.alloc().initWithResponder_(
+                           self.responder.nextResponder())
+        # Install the interceptor
+        self.responder.setNextResponder_(next_intercepter)
+        # Send event along
+        self.responder.keyDown_(event)
+        # Restore old nextResponder value
+        self.responder.setNextResponder_(next_intercepter.responder)
+
+    def sendKeyDownToWrapper_(self, event):
+        """Give a keyDown event to the wrapper for our responder
+
+        Return True if the wrapper handled the event
+        """
+        key = event.charactersIgnoringModifiers()
+        if len(key) != 1 or not key.isalnum():
+            key = osxmenus.REVERSE_KEYS_MAP.get(key)
+        mods = osxmenus.translate_event_modifiers(event)
+        wrapper = wrappermap.wrapper(self.responder)
+        if isinstance(wrapper, Widget) or isinstance(wrapper, Window):
+            if wrapper.emit('key-press', key, mods):
+                return True
+        return False
+
+class MiroWindow(NSWindow):
+    def initWithContentRect_styleMask_backing_defer_(self, rect, mask,
+            backing, defer):
+        self = NSWindow.initWithContentRect_styleMask_backing_defer_(self,
+                rect, mask, backing, defer)
+        self._last_focus_chain = None
+        return self
+
+    def handleKeyDown_(self, event):
+        if self.handle_tab_navigation(event):
+            return
+        interceptor = MiroResponderInterceptor.alloc().initWithResponder_(
+                          self.firstResponder())
+        interceptor.keyDown_(event)
+
+    def handle_tab_navigation(self, event):
+        """Handle tab navigation through the window.
+
+        :returns: True if we handled the event
+        """
+        keystr = event.charactersIgnoringModifiers()
+        if keystr[0] == NSTabCharacter:
+            # handle cycling through views with Tab.
+            self.focusNextKeyView_(True)
+            return True
+        elif keystr[0] == NSBackTabCharacter:
+            self.focusNextKeyView_(False)
+            return True
+        return False
+
+    def acceptsMouseMovedEvents(self):
+        # HACK: for some reason calling setAcceptsMouseMovedEvents_() doesn't
+        # work, we have to forcefully override this method.
+        return NO
+
+    def sendEvent_(self, event):
+        if event.type() == NSKeyDown:
+            self.handleKeyDown_(event)
+        else:
+            NSWindow.sendEvent_(self, event)
+
+    def _calc_current_focus_wrapper(self):
+        responder = self.firstResponder()
+        while responder:
+            wrapper = wrappermap.wrapper(responder)
+            # check if we have a wrapper for the view, if not try the parent
+            # view
+            if wrapper is not None:
+                return wrapper
+            responder = responder.superview()
+        return None
+
+    def focusNextKeyView_(self, is_forward):
+        current_focus = self._calc_current_focus_wrapper()
+        my_wrapper = wrappermap.wrapper(self)
+        next_focus = my_wrapper.get_next_tab_focus(current_focus, is_forward)
+        if next_focus is not None:
+            next_focus.focus()
+
+    def draggingEntered_(self, info):
+        wrapper = wrappermap.wrapper(self)
+        return wrapper.draggingEntered_(info) or NSDragOperationNone
+
+    def draggingUpdated_(self, info):
+        wrapper = wrappermap.wrapper(self)
+        return wrapper.draggingUpdated_(info) or NSDragOperationNone
+
+    def draggingExited_(self, info):
+        wrapper = wrappermap.wrapper(self)
+        wrapper.draggingExited_(info)
+
+    def prepareForDragOperation_(self, info):
+        wrapper = wrappermap.wrapper(self)
+        return wrapper.prepareForDragOperation_(info) or NO
+
+    def performDragOperation_(self, info):
+        wrapper = wrappermap.wrapper(self)
+        return wrapper.performDragOperation_(info) or NO
+
+class MainMiroWindow(MiroWindow):
+    def isMovableByWindowBackground(self):
+        return YES
+
+class Window(signals.SignalEmitter):
+    """See https://develop.participatoryculture.org/index.php/WidgetAPI for a description of the API for this class."""
+    def __init__(self, title, rect=None):
+        signals.SignalEmitter.__init__(self)
+        self.create_signal('active-change')
+        self.create_signal('will-close')
+        self.create_signal('did-move')
+        self.create_signal('key-press')
+        self.create_signal('show')
+        self.create_signal('hide')
+        self.create_signal('on-shown')
+        self.create_signal('file-drag-motion')
+        self.create_signal('file-drag-received')
+        self.create_signal('file-drag-leave')
+        self.is_closing = False
+        if rect is None:
+            rect = Rect(0, 0, 470, 600)
+        self.nswindow = MainMiroWindow.alloc().initWithContentRect_styleMask_backing_defer_(
+                rect.nsrect,
+                self.get_style_mask(),
+                NSBackingStoreBuffered,
+                NO)
+        self.nswindow.setTitle_(title)
+        self.nswindow.setMinSize_(NSSize(470, 600))
+        self.nswindow.setReleasedWhenClosed_(NO)
+        self.content_view = FlippedView.alloc().initWithFrame_(rect.nsrect)
+        self.content_view.setAutoresizesSubviews_(NO)
+        self.nswindow.setContentView_(self.content_view)
+        self.content_widget = None
+        self.view_notifications = NotificationForwarder.create(self.content_view)
+        self.view_notifications.connect(self.on_frame_change, 'NSViewFrameDidChangeNotification')
+        self.window_notifications = NotificationForwarder.create(self.nswindow)
+        self.window_notifications.connect(self.on_activate, 'NSWindowDidBecomeMainNotification')
+        self.window_notifications.connect(self.on_deactivate, 'NSWindowDidResignMainNotification')
+        self.window_notifications.connect(self.on_did_move, 'NSWindowDidMoveNotification')
+        self.window_notifications.connect(self.on_will_close, 'NSWindowWillCloseNotification')
+        wrappermap.add(self.nswindow, self)
+        alive_windows.add(self)
+
+    def get_next_tab_focus(self, current, is_forward):
+        """Return the next widget to cycle through for keyboard focus
+
+        Subclasses can override this to for find-grained control of keyboard
+        focus.
+
+        :param current: currently-focused widget
+        :param is_forward: are we tabbing forward?
+        """
+        return None
+
+    # XXX Use MainWindow not Window for MVCStyle/MiroStyle
+    def get_style_mask(self):
+        return (NSTitledWindowMask | NSClosableWindowMask |
+                NSMiniaturizableWindowMask)
+
+    def set_title(self, title):
+        self.nswindow.setTitle_(title)
+
+    def get_title(self):
+        return self.nswindow.title()
+
+    def on_frame_change(self, notification):
+        self.place_child()
+
+    def on_activate(self, notification):
+        self.emit('active-change')
+
+    def on_deactivate(self, notification):
+        self.emit('active-change')
+
+    def on_did_move(self, notification):
+        self.emit('did-move')
+
+    def on_will_close(self, notification):
+        # unset the first responder.  This allows text entry widgets to get
+        # the NSControlTextDidEndEditingNotification
+        if self.is_closing:
+            logging.info('on_will_close: already closing')
+            return
+        self.is_closing = True
+        self.nswindow.makeFirstResponder_(nil)
+        self.emit('will-close')
+        self.emit('hide')
+        self.is_closing = False
+
+    def is_active(self):
+        return self.nswindow.isMainWindow()
+
+    def is_visible(self):
+        return self.nswindow.isVisible()
+
+    def show(self):
+        if self not in alive_windows:
+            raise ValueError("Window destroyed")
+        self.nswindow.makeKeyAndOrderFront_(nil)
+        self.nswindow.makeMainWindow()
+        self.emit('show')
+        # Cocoa doesn't apply default selections as forcefully as GTK, so
+        # currently there's no need for on-shown to actually wait until the
+        # window has been shown here
+        self.emit('on-shown')
+
+    def close(self):
+        self.nswindow.close()
+
+    def destroy(self):
+        self.close()
+        self.window_notifications.disconnect()
+        self.view_notifications.disconnect()
+        self.nswindow.setContentView_(nil)
+        wrappermap.remove(self.nswindow)
+        alive_windows.discard(self)
+        self.nswindow = None
+
+    def place_child(self):
+        rect = self.nswindow.contentRectForFrameRect_(self.nswindow.frame())
+        self.content_widget.place(NSRect(NSPoint(0, 0), rect.size),
+                self.content_view)
+
+    def hookup_content_widget_signals(self):
+        self.size_req_handler = self.content_widget.connect('size-request-changed',
+                self.on_content_widget_size_request_change)
+
+    def unhook_content_widget_signals(self):
+        self.content_widget.disconnect(self.size_req_handler)
+        self.size_req_handler = None
+
+    def on_content_widget_size_request_change(self, widget, old_size):
+        self.update_size_constraints()
+
+    def set_content_widget(self, widget):
+        if self.content_widget:
+            self.content_widget.remove_viewport()
+            self.unhook_content_widget_signals()
+        self.content_widget = widget
+        self.hookup_content_widget_signals()
+        self.place_child()
+        self.update_size_constraints()
+
+    def update_size_constraints(self):
+        width, height = self.content_widget.get_size_request()
+        # It is possible the window is torn down between the size invalidate
+        # request and the actual size invalidation invocation.  So check
+        # to see if nswindow is there if not then do not do anything.
+        if self.nswindow:
+            # FIXME: I'm not sure that this code does what we want it to do.
+            # It enforces the min-size when the user drags the window, but I
+            # think it should also call setContentSize_ if the window is
+            # currently too small to fit the content - BDK
+            self.nswindow.setContentMinSize_(NSSize(width, height))
+            rect = self.nswindow.contentRectForFrameRect_(self.nswindow.frame())
+            if rect.size.width < width or rect.size.height < height:
+                logging.warn("Content widget too large for this window "
+                        "size available: %dx%d widget size: %dx%d",
+                        rect.size.width, rect.size.height, width, height)
+
+    def get_content_widget(self):
+        return self.content_widget
+
+    def get_frame(self):
+        frame = self.nswindow.frame()
+        frame.size.height -= 22
+        return NSRectWrapper(frame)
+
+    def connect_menu_keyboard_shortcuts(self):
+        # All OS X windows are connected to the menu shortcuts
+        pass
+
+    def accept_file_drag(self, val):
+        if not val:
+            self.drag_dest = None
+        else:
+            self.drag_dest = NSDragOperationCopy
+            self.nswindow.registerForDraggedTypes_([NSFilenamesPboardType])
+
+    def prepareForDragOperation_(self, info):
+        return NO if self.drag_dest is None else YES
+
+    def performDragOperation_(self, info):
+        pb = info.draggingPasteboard()
+        available_types = set(pb.types()) & set([NSFilenamesPboardType])
+        drag_ok = False
+        if available_types:
+            type_ = available_types.pop()
+            # DANCE!  Everybody dance for portable Python code!
+            values = [unicode(
+                      NSURL.fileURLWithPath_(v).filePathURL()).encode('utf-8')
+                      for v in list(pb.propertyListForType_(type_))]
+            self.emit('file-drag-received', values)
+            drag_ok = True
+        self.draggingExited_(info)
+        return drag_ok
+
+    def draggingEntered_(self, info):
+        return self.draggingUpdated_(info)
+
+    def draggingUpdated_(self, info):
+        self.emit('file-drag-motion')
+        return self.drag_dest
+
+    def draggingExited_(self, info):
+        self.emit('file-drag-leave')
+
+    def center(self):
+        self.nswindow.center()
+
+class MainWindow(Window):
+    def __init__(self, title, rect):
+        Window.__init__(self, title, rect)
+        self.nswindow.setReleasedWhenClosed_(NO)
+
+    def close(self):
+        self.nswindow.orderOut_(nil)
+
+class DialogBase(object):
+    def __init__(self):
+        self.sheet_parent = None
+    def set_transient_for(self, window):
+        self.sheet_parent = window
+
+class MiroPanel(NSPanel):
+    def cancelOperation_(self, event):
+        wrappermap.wrapper(self).end_with_code(-1)
+
+class Dialog(DialogBase):
+    def __init__(self, title, description=None):
+        DialogBase.__init__(self)
+        self.title = title
+        self.description = description
+        self.buttons = []
+        self.extra_widget = None
+        self.window = None
+        self.running = False
+
+    def add_button(self, text):
+        button = Button(text)
+        button.set_size(widgetconst.SIZE_NORMAL)
+        button.connect('clicked', self.on_button_clicked, len(self.buttons))
+        self.buttons.append(button)
+
+    def on_button_clicked(self, button, code):
+        self.end_with_code(code)
+
+    def end_with_code(self, code):
+        if self.sheet_parent is not None:
+            NSApp().endSheet_returnCode_(self.window, code)
+        else:
+            NSApp().stopModalWithCode_(code)
+
+    def build_text(self):
+        vbox = VBox(spacing=6)
+        if self.description is not None:
+            description_label = Label(self.description, wrap=True)
+            description_label.set_bold(True)
+            description_label.set_size_request(360, -1)
+            vbox.pack_start(description_label)
+        return vbox
+
+    def build_buttons(self):
+        hbox = HBox(spacing=12)
+        for button in reversed(self.buttons):
+            hbox.pack_start(button)
+        alignment = Alignment(xalign=1.0, yscale=1.0)
+        alignment.add(hbox)
+        return alignment
+
+    def build_content(self):
+        vbox = VBox(spacing=12)
+        vbox.pack_start(self.build_text())
+        if self.extra_widget:
+            vbox.pack_start(self.extra_widget)
+        vbox.pack_start(self.build_buttons())
+        alignment = Alignment(xscale=1.0, yscale=1.0)
+        alignment.set_padding(12, 12, 17, 17)
+        alignment.add(vbox)
+        return alignment
+
+    def build_window(self):
+        self.content_widget = self.build_content()
+        width, height = self.content_widget.get_size_request()
+        width = max(width, 400)
+        window = MiroPanel.alloc()
+        window.initWithContentRect_styleMask_backing_defer_(
+                NSMakeRect(400, 400, width, height),
+                NSTitledWindowMask, NSBackingStoreBuffered, NO)
+        view = FlippedView.alloc().initWithFrame_(NSMakeRect(0, 0, width,
+            height))
+        window.setContentView_(view)
+        window.setTitle_(self.title)
+        self.content_widget.place(view.frame(), view)
+        if self.buttons:
+            self.buttons[0].make_default()
+        return window
+
+    def hookup_content_widget_signals(self):
+        self.size_req_handler = self.content_widget.connect(
+                'size-request-changed',
+                self.on_content_widget_size_request_change)
+
+    def unhook_content_widget_signals(self):
+        self.content_widget.disconnect(self.size_req_handler)
+        self.size_req_handler = None
+
+    def on_content_widget_size_request_change(self, widget, old_size):
+        width, height = self.content_widget.get_size_request()
+        # It is possible the window is torn down between the size invalidate
+        # request and the actual size invalidation invocation.  So check
+        # to see if nswindow is there if not then do not do anything.
+        if self.window and (width, height) != old_size:
+            self.change_content_size(width, height)
+
+    def change_content_size(self, width, height):
+        content_rect = self.window.contentRectForFrameRect_(
+                self.window.frame())
+        # Cocoa's coordinate system is funky, adjust y so that the top stays
+        # in place
+        content_rect.origin.y += (content_rect.size.height - height)
+        # change our frame to fit the new content.  It would be nice to
+        # animate the change, but timers don't work when we are displaying a
+        # modal dialog
+        content_rect.size = NSSize(width, height)
+        new_frame = self.window.frameRectForContentRect_(content_rect)
+        self.window.setFrame_display_(new_frame, NO)
+        # Need to call place() again, since our window has changed size
+        contentView = self.window.contentView()
+        self.content_widget.place(contentView.frame(), contentView)
+
+    def run(self):
+        self.window = self.build_window()
+        wrappermap.add(self.window, self)
+        self.hookup_content_widget_signals()
+        self.running = True
+        if self.sheet_parent is None:
+            response = NSApp().runModalForWindow_(self.window)
+            if self.window:
+                self.window.close()
+        else:
+            delegate = SheetDelegate.alloc().init()
+            NSApp().beginSheet_modalForWindow_modalDelegate_didEndSelector_contextInfo_(
+                self.window, self.sheet_parent.nswindow,
+                delegate, 'sheetDidEnd:returnCode:contextInfo:', 0)
+            response = NSApp().runModalForWindow_(self.window)
+            if self.window:
+                # self.window won't be around if we call destroy() to cancel
+                # the dialog
+                self.window.orderOut_(nil)
+        self.running = False
+        self.unhook_content_widget_signals()
+
+        if response < 0:
+            return -1
+        return response
+
+    def destroy(self):
+        if self.running:
+            NSApp().stopModalWithCode_(-1)
+
+        if self.window is not None:
+            self.window.setContentView_(None)
+            self.window.close()
+        self.window = None
+        self.buttons = None
+        self.extra_widget = None
+
+    def set_extra_widget(self, widget):
+        self.extra_widget = widget
+
+    def get_extra_widget(self):
+        return self.extra_widget
+
+class SheetDelegate(NSObject):
+    @AppHelper.endSheetMethod
+    def sheetDidEnd_returnCode_contextInfo_(self, sheet, return_code, info):
+        NSApp().stopModalWithCode_(return_code)
+
+class FileDialogBase(DialogBase):
+    def __init__(self):
+        DialogBase.__init__(self)
+        self._types = None
+        self._filename = None
+        self._directory = None
+        self._filter_on_run = True
+
+    def run(self):
+        self._panel.setAllowedFileTypes_(self._types)
+        if self.sheet_parent is None:
+            if self._filter_on_run:
+                response = self._panel.runModalForDirectory_file_types_(self._directory, self._filename, self._types)
+            else:
+                response = self._panel.runModalForDirectory_file_(self._directory, self._filename)
+        else:
+            delegate = SheetDelegate.alloc().init()
+            if self._filter_on_run:
+                self._panel.beginSheetForDirectory_file_types_modalForWindow_modalDelegate_didEndSelector_contextInfo_(
+                    self._directory, self._filename, self._types,
+                    self.sheet_parent.nswindow, delegate, 'sheetDidEnd:returnCode:contextInfo:', 0)
+            else:
+                self._panel.beginSheetForDirectory_file_modalForWindow_modalDelegate_didEndSelector_contextInfo_(
+                    self._directory, self._filename,
+                    self.sheet_parent.nswindow, delegate, 'sheetDidEnd:returnCode:contextInfo:', 0)
+            response = NSApp().runModalForWindow_(self._panel)
+            self._panel.orderOut_(nil)
+        return response
+
+class FileSaveDialog(FileDialogBase):
+    def __init__(self, title):
+        FileDialogBase.__init__(self)
+        self._title = title
+        self._panel = NSSavePanel.savePanel()
+        self._panel.setCanChooseFiles_(YES)
+        self._panel.setCanChooseDirectories_(NO)
+        self._filename = None
+        self._filter_on_run = False
+
+    def set_filename(self, s):
+        self._filename = filename_to_unicode(s)
+
+    def get_filename(self):
+        # Use encode('utf-8') instead of unicode_to_filename, because
+        # unicode_to_filename has code to make sure nextFilename works, but it's
+        # more important here to not change the filename.
+        return self._filename.encode('utf-8')
+
+    def run(self):
+        response = FileDialogBase.run(self)
+        if response == NSFileHandlingPanelOKButton:
+            self._filename = self._panel.filename()
+            return 0
+        self._filename = ""
+
+    def destroy(self):
+        self._panel = None
+
+    set_path = set_filename
+    get_path = get_filename
+
+class FileOpenDialog(FileDialogBase):
+    def __init__(self, title):
+        FileDialogBase.__init__(self)
+        self._title = title
+        self._panel = NSOpenPanel.openPanel()
+        self._panel.setCanChooseFiles_(YES)
+        self._panel.setCanChooseDirectories_(NO)
+        self._filenames = None
+
+    def set_select_multiple(self, value):
+        if value:
+            self._panel.setAllowsMultipleSelection_(YES)
+        else:
+            self._panel.setAllowsMultipleSelection_(NO)
+
+    def set_directory(self, d):
+        self._directory = filename_to_unicode(d)
+
+    def set_filename(self, s):
+        self._filename = filename_to_unicode(s)
+
+    def add_filters(self, filters):
+        self._types = []
+        for _, t in filters:
+            self._types += t
+
+    def get_filename(self):
+        if self._filenames is None:
+            # canceled
+            return None
+        return self.get_filenames()[0]
+
+    def get_filenames(self):
+        if self._filenames is None:
+            # canceled
+            return []
+        # Use encode('utf-8') instead of unicode_to_filename, because
+        # unicode_to_filename has code to make sure nextFilename works, but it's
+        # more important here to not change the filename.
+        return [f.encode('utf-8') for f in self._filenames]
+
+    def run(self):
+        response = FileDialogBase.run(self)
+        if response == NSFileHandlingPanelOKButton:
+            self._filenames = self._panel.filenames()
+            return 0
+        self._filename = ''
+        self._filenames = None
+
+    def destroy(self):
+        self._panel = None
+
+    set_path = set_filename
+    get_path = get_filename
+
+class DirectorySelectDialog(FileDialogBase):
+    def __init__(self, title):
+        FileDialogBase.__init__(self)
+        self._title = title
+        self._panel = NSOpenPanel.openPanel()
+        self._panel.setCanChooseFiles_(NO)
+        self._panel.setCanChooseDirectories_(YES)
+        self._directory = None
+
+    def set_directory(self, d):
+        self._directory = filename_to_unicode(d)
+
+    def get_directory(self):
+        # Use encode('utf-8') instead of unicode_to_filename, because
+        # unicode_to_filename has code to make sure nextFilename
+        # works, but it's more important here to not change the
+        # filename.
+        return self._directory.encode('utf-8')
+
+    def run(self):
+        response = FileDialogBase.run(self)
+        if response == NSFileHandlingPanelOKButton:
+            self._directory = self._panel.filenames()[0]
+            return 0
+        self._directory = ""
+
+    def destroy(self):
+        self._panel = None
+
+    set_path = set_directory
+    get_path = get_directory
+
+class AboutDialog(DialogBase):
+    def run(self):
+        optionsDictionary = dict()
+        #revision = app.config.get(prefs.APP_REVISION_NUM)
+        #if revision:
+        #    optionsDictionary['Version'] = revision
+        if not optionsDictionary:
+            optionsDictionary = nil
+        NSApplication.sharedApplication().orderFrontStandardAboutPanelWithOptions_(optionsDictionary)
+    def destroy(self):
+        pass
+
+class AlertDialog(DialogBase):
+    def __init__(self, title, message, alert_type):
+        DialogBase.__init__(self)
+        self._nsalert = NSAlert.alloc().init();
+        self._nsalert.setMessageText_(title)
+        self._nsalert.setInformativeText_(message)
+        self._nsalert.setAlertStyle_(alert_type)
+    def add_button(self, text):
+        self._nsalert.addButtonWithTitle_(text)
+    def run(self):
+        self._nsalert.runModal()
+    def destroy(self):
+        self._nsalert = nil
+
+class PreferenceItem(NSToolbarItem):
+
+    def setPanel_(self, panel):
+        self.panel = panel
+
+class PreferenceToolbarDelegate(NSObject):
+
+    def initWithPanels_identifiers_window_(self, panels, identifiers, window):
+        self = super(PreferenceToolbarDelegate, self).init()
+        self.panels = panels
+        self.identifiers = identifiers
+        self.window = window
+        return self
+
+    def toolbarAllowedItemIdentifiers_(self, toolbar):
+        return self.identifiers
+
+    def toolbarDefaultItemIdentifiers_(self, toolbar):
+        return self.identifiers
+
+    def toolbarSelectableItemIdentifiers_(self, toolbar):
+        return self.identifiers
+
+    def toolbar_itemForItemIdentifier_willBeInsertedIntoToolbar_(self, toolbar,
+                                                                 itemIdentifier,
+                                                                 flag):
+        panel = self.panels[itemIdentifier]
+        item = PreferenceItem.alloc().initWithItemIdentifier_(itemIdentifier)
+        item.setLabel_(unicode(panel[1]))
+        item.setImage_(NSImage.imageNamed_(u"pref_tab_%s" % itemIdentifier))
+        item.setAction_("switchPreferenceView:")
+        item.setTarget_(self)
+        item.setPanel_(panel[0])
+        return item
+
+    def validateToolbarItem_(self, item):
+        return YES
+
+    def switchPreferenceView_(self, sender):
+        self.window.do_select_panel(sender.panel, YES)
+
+class DialogWindow(Window):
+    def __init__(self, title, rect, allow_miniaturize=False):
+        self.allow_miniaturize = allow_miniaturize
+        Window.__init__(self, title, rect)
+        self.nswindow.setShowsToolbarButton_(NO)
+
+    def get_style_mask(self):
+        mask = (NSTitledWindowMask | NSClosableWindowMask)
+        if self.allow_miniaturize:
+            mask |= NSMiniaturizableWindowMask
+        return mask
+
+class DonateWindow(Window):
+    def __init__(self, title):
+        Window.__init__(self, title, Rect(0, 0, 640, 440))
+        self.panels = dict()
+        self.identifiers = list()
+        self.first_show = True
+        self.nswindow.setShowsToolbarButton_(NO)
+        self.nswindow.setReleasedWhenClosed_(NO)
+        self.app_notifications = NotificationForwarder.create(NSApp())
+        self.app_notifications.connect(self.on_app_quit,
+            'NSApplicationWillTerminateNotification')
+
+    def destroy(self):
+        super(PreferencesWindow, self).destroy()
+        self.app_notifications.disconnect()
+
+    def get_style_mask(self):
+        return (NSTitledWindowMask | NSClosableWindowMask |
+                NSMiniaturizableWindowMask)
+
+    def show(self):
+        if self.first_show:
+            self.nswindow.center()
+            self.first_show = False
+        Window.show(self)
+
+    def on_app_quit(self, notification):
+        self.close()
+
+class PreferencesWindow(Window):
+    def __init__(self, title):
+        Window.__init__(self, title, Rect(0, 0, 640, 440))
+        self.panels = dict()
+        self.identifiers = list()
+        self.first_show = True
+        self.nswindow.setShowsToolbarButton_(NO)
+        self.nswindow.setReleasedWhenClosed_(NO)
+        self.app_notifications = NotificationForwarder.create(NSApp())
+        self.app_notifications.connect(self.on_app_quit,
+            'NSApplicationWillTerminateNotification')
+
+    def destroy(self):
+        super(PreferencesWindow, self).destroy()
+        self.app_notifications.disconnect()
+
+    def get_style_mask(self):
+        return (NSTitledWindowMask | NSClosableWindowMask |
+                NSMiniaturizableWindowMask)
+
+    def append_panel(self, name, panel, title, image_name):
+        self.panels[name] = (panel, title)
+        self.identifiers.append(name)
+
+    def finish_panels(self):
+        self.tbdelegate = PreferenceToolbarDelegate.alloc().initWithPanels_identifiers_window_(self.panels, self.identifiers, self)
+        toolbar = NSToolbar.alloc().initWithIdentifier_(u"Preferences")
+        toolbar.setAllowsUserCustomization_(NO)
+        toolbar.setDelegate_(self.tbdelegate)
+
+        self.nswindow.setToolbar_(toolbar)
+
+    def select_panel(self, index):
+        panel = self.identifiers[index]
+        self.nswindow.toolbar().setSelectedItemIdentifier_(panel)
+        self.do_select_panel(self.panels[panel][0], NO)
+
+    def do_select_panel(self, panel, animate):
+        wframe = self.nswindow.frame()
+        vsize = list(panel.get_size_request())
+        if vsize[0] < 650:
+            vsize[0] = 650
+        if vsize[1] < 200:
+            vsize[1] = 200
+
+        toolbarHeight = wframe.size.height - self.nswindow.contentView().frame().size.height
+        wframe.origin.y += wframe.size.height - vsize[1] - toolbarHeight
+        wframe.size = (vsize[0], vsize[1] + toolbarHeight)
+
+        self.set_content_widget(panel)
+        self.nswindow.setFrame_display_animate_(wframe, YES, animate)
+
+    def show(self):
+        if self.first_show:
+            self.nswindow.center()
+            self.first_show = False
+        Window.show(self)
+
+    def on_app_quit(self, notification):
+        self.close()
+
+def get_first_time_dialog_coordinates(width, height):
+    """Returns the coordinates for the first time dialog.
+    """
+    # windowFrame is None on first run.  in that case, we want
+    # to put librevideoconverter in the middle.
+    mainscreen = NSScreen.mainScreen()
+    rect = mainscreen.frame()
+
+    x = (rect.size.width - width) / 2
+    y = (rect.size.height - height) / 2
+
+    return x, y
diff --git a/lvc/widgets/osx/wrappermap.py b/lvc/widgets/osx/wrappermap.py
new file mode 100644
index 0000000..624a496
--- /dev/null
+++ b/lvc/widgets/osx/wrappermap.py
@@ -0,0 +1,48 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+""".wrappermap -- Map NSViews and NSWindows to the
+Widget that wraps them.
+"""
+
+# Maps NSViews/NSWinows  -> wrapper objects.
+wrapper_mapping = dict()
+
+def wrapper(wrapped):
+    """Find the wrapper object for an NSView/NSWindow."""
+    try:
+        return wrapper_mapping[wrapped]
+    except KeyError:
+        return None
+
+def add(wrapped, wrapper):
+    wrapper_mapping[wrapped] = wrapper
+
+def remove(wrapped):
+    del wrapper_mapping[wrapped]
diff --git a/lvc/widgets/tablescroll.py b/lvc/widgets/tablescroll.py
new file mode 100644
index 0000000..f8b1acb
--- /dev/null
+++ b/lvc/widgets/tablescroll.py
@@ -0,0 +1,154 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""tablescroll.py -- High-level scroll management. This ensures that behavior
+like scroll_to_item works the same way across platforms.
+"""
+
+from lvc.errors import WidgetActionError
+
+
+class ScrollbarOwnerMixin(object):
+    """Scrollbar management for TableView.
+
+    External methods have undecorated names; internal methods start with _.
+
+    External methods:
+    - handle failure themselves (e.g. return None or retry later)
+    - return basic data types (e.g. (x, y) tuples)
+    - use "tree" coordinates
+
+    Internal methods (intended to be used by ScrollbarOwnerMixin and the
+    platform implementations):
+    - raise WidgetActionError subclasses on failure
+    - use Rect/Point structs
+    - also use "tree" coordinates
+    """
+    def __init__(self, _work_around_17153=False):
+        self.__work_around_17153 = _work_around_17153
+        self._scroll_to_iter_callback = None
+        self.create_signal('scroll-range-changed')
+
+    def scroll_to_iter(self, iter_, manual=True, recenter=False):
+        """Scroll the given item into view.
+
+        manual: scroll even if we were not following the playing item
+        recenter: scroll even if item is in top half of view
+        """
+        try:
+            item = self._get_item_area(iter_)
+            visible = self._get_visible_area()
+            manually_scrolled = self._manually_scrolled
+        except WidgetActionError:
+            if self._scroll_to_iter_callback:
+                # We just retried and failed. Do nothing; we will retry again
+                # next time scrollable range changes.
+                return
+            # We just tried and failed; schedule a retry when the scrollable
+            # range changes.
+            self._scroll_to_iter_callback = self.connect('scroll-range-changed',
+                    lambda *a: self.scroll_to_iter(iter_, manual, recenter))
+            return
+        # If the above succeeded, we know the iter's position; this means we can
+        # set_scroll_position to that position. That may work now or be
+        # postponed until later, but either way we're done with scroll_to_iter.
+        if self._scroll_to_iter_callback:
+            self.disconnect(self._scroll_to_iter_callback)
+            self._scroll_to_iter_callback = None
+        visible_bottom = visible.y + visible.height
+        visible_middle = visible.y + visible.height // 2
+        item_bottom = item.y + item.height
+        item_middle = item.y + item.height // 2
+        in_top = item_bottom >= visible.y and item.y <= visible_middle
+        in_bottom = item_bottom >= visible_middle and item.y <= visible_bottom
+        if self._should_scroll(
+                manual, in_top, in_bottom, recenter, manually_scrolled):
+            destination = item_middle - visible.height // 2
+            self._set_vertical_scroll(destination)
+            # set_scroll_position will take care of scroll to the position when
+            # possible; this may or may not be now, but our work here is done.
+
+    def set_scroll_position(self, position, restore_only=False,
+            _hack_for_17153=False):
+        """Scroll the top left corner to the given (x, y) offset from the origin
+        of the view.
+
+        restore_only: set the value only if no other value has been set yet
+        """
+        if _hack_for_17153 and not self.__work_around_17153:
+            return
+        if not restore_only or not self._position_set:
+            self._set_scroll_position(position)
+
+    @classmethod
+    def _should_scroll(cls,
+            manual, in_top, in_bottom, recenter, manually_scrolled):
+        if not manual and manually_scrolled:
+            # The user has moved the scrollbars since we last autoscrolled, and
+            # we're deciding whether we should resume autoscrolling.
+            # We want to do that when the currently-playing item catches up to
+            # the center of the screen i.e. is part above the center, part below
+            return in_top and in_bottom
+        # This is a manual scroll, or we're already autoscrolling - so we no
+        # longer need to worry about either manual or manually_scrolled
+        if in_top:
+            # The item is in the top half; let playback catch up with the
+            # current scroll position, unless recentering has been requested
+            return recenter
+        if in_bottom:
+            # We land here when:
+            # - playback has begun with an item in the bottom half of the screen
+            # - scroll is following sequential playback
+            # Either way we want to jump down to the item.
+            return True
+        # We're scrolling to an item that's not in view because:
+        # - playback has begun with an item that is out of sight
+        # - we're autoscrolling on shuffle
+        # Either way we want to show the item.
+        return True
+
+    def reset_scroll(self):
+        """To scroll back to the origin; platform code might want to do
+        something special to forget the current position when this happens.
+        """
+        self.set_scroll_position((0, 0))
+
+    def get_scroll_position(self):
+        """Returns the current scroll position, or None if not ready."""
+        try:
+            return tuple(self._get_scroll_position())
+        except WidgetActionError:
+            return None
+
+    def _set_vertical_scroll(self, pos):
+        """Helper to set our vertical position without affecting our horizontal
+        position.
+        """
+        # FIXME: shouldn't reset horizontal position
+        self.set_scroll_position((0, pos))
diff --git a/lvc/widgets/tableselection.py b/lvc/widgets/tableselection.py
new file mode 100644
index 0000000..ee6472c
--- /dev/null
+++ b/lvc/widgets/tableselection.py
@@ -0,0 +1,220 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""tableselection.py -- High-level selection management. Subclasses defined in
+the platform tableview modules provide the platform-specific methods used here.
+"""
+
+from contextlib import contextmanager
+
+from lvc.errors import WidgetActionError, WidgetUsageError
+
+class SelectionOwnerMixin(object):
+    """Encapsulates the selection functionality of a TableView, for
+    consistent behavior across platforms.
+
+    Emits:
+    :signal selection-changed: the selection has been changed
+    :signal selection-invalid: the item selected can no longer be selected
+    :signal deselected: all items have been deselected
+    """
+    def __init__(self):
+        self._ignore_selection_changed = 0
+        self._allow_multiple_select = None
+        self.create_signal('selection-changed')
+        self.create_signal('selection-invalid')
+        self.create_signal('deselected')
+
+    @property
+    def allow_multiple_select(self):
+        """Return whether the widget allows multiple selection."""
+        if self._allow_multiple_select is None:
+            self._allow_multiple_select = self._get_allow_multiple_select()
+        return self._allow_multiple_select
+
+    @allow_multiple_select.setter
+    def allow_multiple_select(self, allow):
+        """Set whether to allow multiple selection; this method is expected
+        always to work.
+        """
+        if self._allow_multiple_select != allow:
+            self._set_allow_multiple_select(allow)
+            self._allow_multiple_select = allow
+
+    @property
+    def num_rows_selected(self):
+        """Override on platforms with a way to count rows without having to
+        retrieve them.
+        """
+        if self.allow_multiple_select:
+            return len(self._get_selected_iters())
+        else:
+            return int(self._get_selected_iter() is not None)
+
+    def select(self, iter_, signal=False):
+        """Try to select an iter.
+
+        :raises WidgetActionError: iter does not exist or is not selectable
+        """
+        self.select_iters((iter_,), signal)
+
+    def select_iters(self, iters, signal=False):
+        """Try to select multiple iters (signaling at most once).
+
+        :raises WidgetActionError: iter does not exist or is not selectable
+        """
+        with self._ignoring_changes(not signal):
+            for iter_ in iters:
+                self._select(iter_)
+        if not all(self._is_selected(iter_) for iter_ in iters):
+            raise WidgetActionError("the specified iter cannot be selected")
+
+    def is_selected(self, iter_):
+        """Test if an iter is selected"""
+        return self._is_selected(iter_)
+
+    def unselect(self, iter_):
+        """Unselect an Iter. Fails silently if the Iter is not selected.
+        """
+        self._validate_iter(iter_)
+        with self._ignoring_changes():
+            self._unselect(iter_)
+
+    def unselect_iters(self, iters):
+        """Unselect iters. Fails silently if the iters are not selected."""
+        with self._ignoring_changes():
+            for iter_ in iters:
+                self.unselect(iter_)
+
+    def unselect_all(self, signal=True):
+        """Unselect all. emits only the 'deselected' signal."""
+        with self._ignoring_changes():
+            self._unselect_all()
+            if signal:
+                self.emit('deselected')
+
+    def on_selection_changed(self, _widget_or_notification):
+        """When we receive a selection-changed signal, we forward it if we're
+        not in a 'with _ignoring_changes' block. Selection-changed
+        handlers are run in an ignoring block, and anything that changes the
+        selection to reflect the current state.
+        """
+        # don't bother sending out a second selection-changed signal if
+        # the handler changes the selection (#15767)
+        if not self._ignore_selection_changed:
+            with self._ignoring_changes():
+                self.emit('selection-changed')
+
+    def get_selection_as_strings(self):
+        """Returns the current selection as a list of strings.
+        """
+        return [self._iter_to_string(iter_) for iter_ in self.get_selection()]
+
+    def set_selection_as_strings(self, selected):
+        """Given a list of selection strings, selects each Iter represented by
+        the strings.
+
+        Raises WidgetActionError upon failure.
+        """
+        # iter may not be destringable (yet) - bounds error
+        # destringed iter not selectable if parent isn't open (yet)
+        self.set_selection(self._iter_from_string(sel) for sel in selected)
+
+    def get_cursor(self):
+        """Get the location of the keyboard cursor for the tableview.
+
+        Returns a string that represents the row that the keyboard cursor is
+        on.
+        """
+
+    def set_cursor(self, location):
+        """Set the location of the keyboard cursor for the tableview.
+
+        :param location: return value from a call to get_cursor()
+
+        Raises WidgetActionError upon failure.
+        """
+
+    def get_selection(self):
+        """Returns a list of GTK Iters. Works regardless of whether multiple
+        selection is enabled.
+        """
+        return self._get_selected_iters()
+
+    def get_selected(self):
+        """Return the single selected item.
+
+        :raises WidgetUsageError: multiple selection is enabled
+        """
+        if self.allow_multiple_select:
+            raise WidgetUsageError("table allows multiple selection")
+        return self._get_selected_iter()
+
+    def _validate_iter(self, iter_):
+        """Check whether an iter is valid.
+
+        :raises WidgetDomainError: the iter is not valid
+        :raises WidgetActionError: there is no model right now
+        """
+
+    @contextmanager
+    def _ignoring_changes(self, ignoring=True):
+        """Use this with with to prevent sending signals when we're changing
+        our own selection; that way, when we get a signal, we know it's
+        something important.
+        """
+        if ignoring:
+            self._ignore_selection_changed += 1
+        try:
+            yield
+        finally:
+            if ignoring:
+                self._ignore_selection_changed -= 1
+
+    @contextmanager
+    def preserving_selection(self):
+        """Prevent selection changes in a block from having any effect or
+        sticking - no signals will be sent, and the selection will be restored
+        to its original value when the block exits.
+        """
+        iters = self._get_selected_iters()
+        with self._ignoring_changes():
+            try:
+                yield
+            finally:
+                self.set_selection(iters)
+
+    def set_selection(self, iters, signal=False):
+        """Set the selection to the given iters, replacing any previous
+        selection and signaling at most once.
+        """
+        self.unselect_all(signal=False)
+        for iter_ in iters:
+            self.select(iter_, signal=False)
+        if signal: self.emit('selection-changed')
diff --git a/lvc/widgets/widgetconst.py b/lvc/widgets/widgetconst.py
new file mode 100644
index 0000000..bbb513c
--- /dev/null
+++ b/lvc/widgets/widgetconst.py
@@ -0,0 +1,44 @@
+# @Base: Miro - an RSS based video player application
+# Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011
+# Participatory Culture Foundation
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the OpenSSL
+# library.
+#
+# You must obey the GNU General Public License in all respects for all of
+# the code used other than OpenSSL. If you modify file(s) with this
+# exception, you may extend this exception to your version of the file(s),
+# but you are not obligated to do so. If you do not wish to do so, delete
+# this exception statement from your version. If you delete this exception
+# statement from all source files in the program, then also delete it here.
+
+"""``miro.frontends.widgets.widgetconst`` -- Constants for the widgets
+frontend.
+"""
+
+# Control sizes
+SIZE_NORMAL = -1
+SIZE_SMALL = -2
+
+TEXT_JUSTIFY_LEFT = 0
+TEXT_JUSTIFY_RIGHT = 1
+TEXT_JUSTIFY_CENTER = 2
+
+# cursors
+CURSOR_NORMAL = 0
+CURSOR_POINTING_HAND = 1
diff --git a/lvc/widgets/widgetutil.py b/lvc/widgets/widgetutil.py
new file mode 100644
index 0000000..861ed5f
--- /dev/null
+++ b/lvc/widgets/widgetutil.py
@@ -0,0 +1,225 @@
+from math import pi as PI
+from lvc.widgets import widgetset
+from lvc.resources import image_path
+
+def make_surface(image_name, height=None):
+    path = image_path(image_name + '.png')
+    image = widgetset.Image(path)
+    if height is not None:
+        image = image.resize(image.width, height)
+    return widgetset.ImageSurface(image)
+
+def font_scale_from_osx_points(points):
+    """Create a font scale so that it's points large on OS X.
+
+    Assumptions (these should be true for OS X)
+        - the default font size is 13pt
+        - the DPI is 72ppi
+    """
+    return points / 13.0
+
+def css_to_color(css_string):
+    parts = (css_string[1:3], css_string[3:5], css_string[5:7])
+    return tuple((int(value, 16) / 255.0) for value in parts)
+
+def align(widget, xalign=0, yalign=0, xscale=0, yscale=0,
+        top_pad=0, bottom_pad=0, left_pad=0, right_pad=0):
+    """Create an alignment, then add widget to it and return the alignment.
+    """
+    alignment = widgetset.Alignment(xalign, yalign, xscale, yscale,
+                          top_pad, bottom_pad, left_pad, right_pad)
+    alignment.add(widget)
+    return alignment
+
+def align_center(widget, top_pad=0, bottom_pad=0, left_pad=0, right_pad=0):
+    """Wrap a widget in an Alignment that will center it horizontally.
+    """
+    return align(widget, 0.5, 0, 0, 1,
+            top_pad, bottom_pad, left_pad, right_pad)
+
+def align_right(widget, top_pad=0, bottom_pad=0, left_pad=0, right_pad=0):
+    """Wrap a widget in an Alignment that will align it left.
+    """
+    return align(widget, 1, 0, 0, 1, top_pad, bottom_pad, left_pad, right_pad)
+
+def align_left(widget, top_pad=0, bottom_pad=0, left_pad=0, right_pad=0):
+    """Wrap a widget in an Alignment that will align it right.
+    """
+    return align(widget, 0, 0, 0, 1, top_pad, bottom_pad, left_pad, right_pad)
+
+def align_middle(widget, top_pad=0, bottom_pad=0, left_pad=0, right_pad=0):
+    """Wrap a widget in an Alignment that will center it vertically.
+    """
+    return align(widget, 0, 0.5, 1, 0,
+            top_pad, bottom_pad, left_pad, right_pad)
+
+def align_top(widget, top_pad=0, bottom_pad=0, left_pad=0, right_pad=0):
+    """Wrap a widget in an Alignment that will align to the top.
+    """
+    return align(widget, 0, 0, 1, 0, top_pad, bottom_pad, left_pad, right_pad)
+
+def align_bottom(widget, top_pad=0, bottom_pad=0, left_pad=0, right_pad=0):
+    """Wrap a widget in an Alignment that will align to the bottom.
+    """
+    return align(widget, 0, 1, 1, 0, top_pad, bottom_pad, left_pad, right_pad)
+
+def pad(widget, top=0, bottom=0, left=0, right=0):
+    """Wrap a widget in an Alignment that will pad it.
+    """
+    alignment = widgetset.Alignment(0, 0, 1, 1,
+                          top, bottom, left, right)
+    alignment.add(widget)
+    return alignment
+
+def round_rect(context, x, y, width, height, edge_radius):
+    """Specifies path of a rectangle with rounded corners.
+    """
+    edge_radius = min(edge_radius, min(width, height)/2.0)
+    inner_width = width - edge_radius*2
+    inner_height = height - edge_radius*2
+    x_inner1 = x + edge_radius
+    x_inner2 = x + width - edge_radius
+    y_inner1 = y + edge_radius
+    y_inner2 = y + height - edge_radius
+
+    context.move_to(x+edge_radius, y)
+    context.rel_line_to(inner_width, 0)
+    context.arc(x_inner2, y_inner1, edge_radius, -PI/2, 0)
+    context.rel_line_to(0, inner_height)
+    context.arc(x_inner2, y_inner2, edge_radius, 0, PI/2)
+    context.rel_line_to(-inner_width, 0)
+    context.arc(x_inner1, y_inner2, edge_radius, PI/2, PI)
+    context.rel_line_to(0, -inner_height)
+    context.arc(x_inner1, y_inner1, edge_radius, PI, PI*3/2)
+
+def round_rect_reverse(context, x, y, width, height, edge_radius):
+    """Specifies path of a rectangle with rounded corners.
+
+    This specifies the rectangle in a counter-clockwise fashion.
+    """
+    edge_radius = min(edge_radius, min(width, height)/2.0)
+    inner_width = width - edge_radius*2
+    inner_height = height - edge_radius*2
+    x_inner1 = x + edge_radius
+    x_inner2 = x + width - edge_radius
+    y_inner1 = y + edge_radius
+    y_inner2 = y + height - edge_radius
+
+    context.move_to(x+edge_radius, y)
+    context.arc_negative(x_inner1, y_inner1, edge_radius, PI*3/2, PI)
+    context.rel_line_to(0, inner_height)
+    context.arc_negative(x_inner1, y_inner2, edge_radius, PI, PI/2)
+    context.rel_line_to(inner_width, 0)
+    context.arc_negative(x_inner2, y_inner2, edge_radius, PI/2, 0)
+    context.rel_line_to(0, -inner_height)
+    context.arc_negative(x_inner2, y_inner1, edge_radius, 0, -PI/2)
+    context.rel_line_to(-inner_width, 0)
+
+def circular_rect(context, x, y, width, height):
+    """Make a path for a rectangle with the left/right side being circles.
+    """
+    radius = height / 2.0
+    inner_width = width - height
+    inner_y = y + radius
+    inner_x1 = x + radius
+    inner_x2 = inner_x1 + inner_width
+
+    context.move_to(inner_x1, y)
+    context.rel_line_to(inner_width, 0)
+    context.arc(inner_x2, inner_y, radius, -PI/2, PI/2)
+    context.rel_line_to(-inner_width, 0)
+    context.arc(inner_x1, inner_y, radius, PI/2, -PI/2)
+
+def circular_rect_negative(context, x, y, width, height):
+    """The same path as ``circular_rect()``, but going counter clockwise.
+    """
+    radius = height / 2.0
+    inner_width = width - height
+    inner_y = y + radius
+    inner_x1 = x + radius
+    inner_x2 = inner_x1 + inner_width
+
+    context.move_to(inner_x1, y)
+    context.arc_negative(inner_x1, inner_y, radius, -PI/2, PI/2)
+    context.rel_line_to(inner_width, 0)
+    context.arc_negative(inner_x2, inner_y, radius, PI/2, -PI/2)
+    context.rel_line_to(-inner_width, 0)
+
+class Shadow(object):
+    """Encapsulates all parameters required to draw shadows.
+    """
+    def __init__(self, color, opacity, offset, blur_radius):
+        self.color = color
+        self.opacity = opacity
+        self.offset = offset
+        self.blur_radius = blur_radius
+
+class ThreeImageSurface(object):
+    """Takes a left, center and right image and draws them to an arbitrary
+    width.  If the width is greater than the combined width of the 3 images,
+    then the center image will be tiled to compensate.
+
+    Example:
+
+    >>> timelinebar = ThreeImageSurface("timelinebar")
+
+    This creates a ``ThreeImageSurface`` using the images
+    ``images/timelinebar_left.png``, ``images/timelinebar_center.png``, and
+    ``images/timelinebar_right.png``.
+
+    Example:
+
+    >>> timelinebar = ThreeImageSurface()
+    >>> img_left = make_surface("timelinebar_left")
+    >>> img_center = make_surface("timelinebar_center")
+    >>> img_right = make_surface("timelinebar_right")
+    >>> timelinebar.set_images(img_left, img_center, img_right)
+
+    This does the same thing, but allows you to explicitly set which images
+    get used.
+    """
+    def __init__(self, basename=None, height=None):
+        self.left = self.center = self.right = None
+        self.height = 0
+        self.width = None
+        if basename is not None:
+            left = make_surface(basename + '_left', height)
+            center = make_surface(basename + '_center', height)
+            right = make_surface(basename + '_right', height)
+            self.set_images(left, center, right)
+
+    def set_images(self, left, center, right):
+        """Sets the left, center and right images to use.
+        """
+        self.left = left
+        self.center = center
+        self.right = right
+        if not (self.left.height == self.center.height == self.right.height):
+            raise ValueError("Images aren't the same height")
+        self.height = self.left.height
+
+    def set_width(self, width):
+        """Manually set a width.
+
+        When ThreeImageSurface have a width, then they have pretty much the
+        same API as ImageSurface does.  In particular, they can now be nested
+        in another ThreeImageSurface.
+        """
+        self.width = width
+
+    def get_size(self):
+        return self.width, self.height
+
+    def draw(self, context, x, y, width, fraction=1.0):
+        left_width = min(self.left.width, width)
+        self.left.draw(context, x, y, left_width, self.height, fraction)
+        self.draw_right(context, x + left_width, y, width - left_width, fraction)
+
+    def draw_right(self, context, x, y, width, fraction=1.0):
+        # draws only the right two images
+
+        right_width = min(self.right.width, width)
+        center_width = int(width - right_width)
+
+        self.center.draw(context, x, y, center_width, self.height, fraction)
+        self.right.draw(context, x + center_width, y, right_width, self.height, fraction)