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):
     self.releaseInbounds = self.stopTracking = self.firedOnce = False
     self.cell().trackMouse_inRect_ofView_untilMouseUp_(event,
             self.bounds(), self, YES)
     if self.releaseInbounds:
         if self.firedOnce:
             wrappermap.wrapper(self).emit('released')
         else:
             wrappermap.wrapper(self).emit('clicked')

    def textDidEndEditing_(self, notification):
        # Handle the user stopping typing.
        text_movement = notification.userInfo().get('NSTextMovement')
        if text_movement == NSReturnTextMovement:
            # user hit return, emit 'validate'
            wrappermap.wrapper(self).emit('validate')

        # HACK: not sure exactly why this line has an effect, but it prevents
        # 17195
        self.stringValue()

 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()
         self.hotspot_tracker.redraw_cell()
         self.hotspot_tracker = None
     else:
         self.SuperClass.mouseUp_(self, event)

    def drawRect_(self, rect):
        context = drawing.DrawingContext(self, self.bounds(), rect)
        context.style = drawing.DrawingStyle()
        wrapper = wrappermap.wrapper(self)
        if self.state() == NSOnState:
            wrapper.state = 'pressed'
        elif self.mouse_inside:
            wrapper.state = 'hover'
        else:
            wrapper.state = 'normal'

        wrappermap.wrapper(self).draw(context, self.layout_manager)
        self.layout_manager.reset()

 def continueTracking_at_inView_(self, lastPoint, at, view):
     if view.isVertical():
         pos = at.y
         size = view.bounds().size.height
     else:
         pos = at.x
         size = view.bounds().size.width
     slider_amount = self.calc_slider_amount(view, pos, size)
     value = (self.maxValue() - self.minValue()) * slider_amount
     self.setFloatValue_(value)
     wrappermap.wrapper(view).emit('moved', value)
     if self.isContinuous():
         wrappermap.wrapper(view).emit('changed', value)
     return YES

    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:
                iter = wrapper.model.iter_for_row(self, row)
                wrapper.emit('row-double-clicked', iter)
            return

        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
        else:
            self.handled_last_mouse_down = False
            self.SuperClass.mouseDown_(self, event)

 def outlineView_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)

 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

 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)

    def viewport_created(self):
        self.video_window = VideoWindow.alloc().initWithContentRect_styleMask_backing_defer_(self.view.frame(), NSBorderlessWindowMask, NSBackingStoreBuffered, NO)
        self.video_window.setContentView_(self.video_view)

        self.adjust_video_frame()
        self.view.window().addChildWindow_ordered_(self.video_window, NSWindowAbove)
        self.video_window.orderFront_(nil)
        self.window_moved_handler = wrappermap.wrapper(self.view.window()).connect('did-move', self.on_window_moved)

 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 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()

 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 validateDrop_dragInfo_parentIter_position_(self, view, drag_info, 
         parent, position):
     typ = self.calcType_(drag_info)
     if typ:
         wrapper = wrappermap.wrapper(view)
         return self.drag_dest.validate_drop(wrapper, self.model, typ,
                 drag_info.draggingSourceOperationMask(), parent,
                 position)
     else:
         return NSDragOperationNone

 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 acceptDrop_dragInfo_parentIter_position_(self, view, drag_info,
         parent, position):
     typ = self.calcType_(drag_info)
     if typ:
         data = drag_info.draggingPasteboard().stringForType_(typ)
         wrapper = wrappermap.wrapper(view)
         return self.drag_dest.accept_drop(wrapper, self.model, typ, 
                 drag_info.draggingSourceOperationMask(), parent,
                 position, data)
     else:
         return NO

 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_(drag_data.keys(), self)
     for typ, value in drag_data.items():
         pasteboard.setString_forType_(value, typ)
     return YES

 def drawRect_(self, rect):
     NSTableHeaderView.drawRect_(self, rect)
     wrapper = wrappermap.wrapper(self.tableView())
     # Manually handle sort column drawing
     for i, column in enumerate(wrapper.columns):
         if column.sort_indicator_visible:
             cell = column._column.headerCell()
             frame = self.headerRectOfColumn_(i)
             cell.highlight_withFrame_inView_(True, frame, self)
             cell.drawSortIndicatorWithFrame_inView_ascending_priority_(
                     frame, self, column.sort_order_ascending, 0)

 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