Python wrappermap.wrapper函数代码示例

 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 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_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_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 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 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 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 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 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 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 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 _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 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 _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 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