path: root/lvc/widgets/osx/tableview.py

# @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 = self not 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)