diff options
Diffstat (limited to 'icon.py')
| -rw-r--r-- | icon.py | 597 |
1 files changed, 422 insertions, 175 deletions
@@ -25,8 +25,11 @@ import re import math import logging -import gobject -import gtk +from gi.repository import GObject +from gi.repository import Gtk +from gi.repository import Gdk +from gi.repository import GdkPixbuf +from gi.repository import Rsvg import cairo from colors import XoColor @@ -125,7 +128,6 @@ class LRU: def keys(self): return self.d.keys() - _BADGE_SIZE = 0.45 @@ -153,9 +155,7 @@ class _SVGLoader(object): logging.error( 'Icon %s, entity %s is invalid.', file_name, entity) - # XXX this is very slow! why? - import rsvg - return rsvg.Handle(data=icon) + return Rsvg.Handle.new_from_data(icon) class _IconInfo(object): @@ -213,11 +213,11 @@ class _IconBuffer(object): return self._loader.load(file_name, entities, self.cache) def _get_attach_points(self, info, size_request): - attach_points = info.get_attach_points() + has_attach_points_, attach_points = info.get_attach_points() if attach_points: - attach_x = float(attach_points[0][0]) / size_request - attach_y = float(attach_points[0][1]) / size_request + attach_x = float(attach_points[0].x) / size_request + attach_y = float(attach_points[0].y) / size_request else: attach_x = attach_y = 0 @@ -229,7 +229,7 @@ class _IconBuffer(object): if self.file_name: icon_info.file_name = self.file_name elif self.icon_name: - theme = gtk.icon_theme_get_default() + theme = Gtk.IconTheme.get_default() size = 50 if self.width != None: @@ -251,20 +251,19 @@ class _IconBuffer(object): return icon_info def _draw_badge(self, context, size, sensitive, widget): - theme = gtk.icon_theme_get_default() + theme = Gtk.IconTheme.get_default() badge_info = theme.lookup_icon(self.badge_name, int(size), 0) if badge_info: badge_file_name = badge_info.get_filename() if badge_file_name.endswith('.svg'): handle = self._loader.load(badge_file_name, {}, self.cache) - dimensions = handle.get_dimension_data() - icon_width = int(dimensions[0]) - icon_height = int(dimensions[1]) + icon_width = handle.props.width + icon_height = handle.props.height pixbuf = handle.get_pixbuf() else: - pixbuf = gtk.gdk.pixbuf_new_from_file(badge_file_name) + pixbuf = GdkPixbuf.Pixbuf.new_from_file(badge_file_name) icon_width = pixbuf.get_width() icon_height = pixbuf.get_height() @@ -274,9 +273,8 @@ class _IconBuffer(object): if not sensitive: pixbuf = self._get_insensitive_pixbuf(pixbuf, widget) - gdkcontext = gtk.gdk.CairoContext(context) - gdkcontext.set_source_pixbuf(pixbuf, 0, 0) - gdkcontext.paint() + Gdk.cairo_set_source_pixbuf(context, pixbuf, 0, 0) + context.paint() def _get_size(self, icon_width, icon_height, padding): if self.width is not None and self.height is not None: @@ -322,20 +320,21 @@ class _IconBuffer(object): self.fill_color = None def _get_insensitive_pixbuf(self, pixbuf, widget): - if not (widget and widget.style): + if not (widget and widget.get_style()): return pixbuf - icon_source = gtk.IconSource() + icon_source = Gtk.IconSource() # Special size meaning "don't touch" icon_source.set_size(-1) icon_source.set_pixbuf(pixbuf) - icon_source.set_state(gtk.STATE_INSENSITIVE) + icon_source.set_state(Gtk.StateType.INSENSITIVE) icon_source.set_direction_wildcarded(False) icon_source.set_size_wildcarded(False) - pixbuf = widget.style.render_icon(icon_source, widget.get_direction(), - gtk.STATE_INSENSITIVE, -1, widget, - 'sugar-icon') + style = widget.get_style() + pixbuf = style.render_icon(icon_source, widget.get_direction(), + Gtk.StateType.INSENSITIVE, -1, widget, + 'sugar-icon') return pixbuf @@ -352,11 +351,10 @@ class _IconBuffer(object): if is_svg: handle = self._load_svg(icon_info.file_name) - dimensions = handle.get_dimension_data() - icon_width = int(dimensions[0]) - icon_height = int(dimensions[1]) + icon_width = handle.props.width + icon_height = handle.props.height else: - pixbuf = gtk.gdk.pixbuf_new_from_file(icon_info.file_name) + pixbuf = GdkPixbuf.Pixbuf.new_from_file(icon_info.file_name) icon_width = pixbuf.get_width() icon_height = pixbuf.get_height() @@ -372,9 +370,7 @@ class _IconBuffer(object): surface = cairo.ImageSurface(cairo.FORMAT_RGB24, int(width), int(height)) context = cairo.Context(surface) - context.set_source_rgb(self.background_color.red, - self.background_color.blue, - self.background_color.green) + context.set_source_color(self.background_color) context.paint() context.scale(float(width) / (icon_width + padding * 2), @@ -388,15 +384,14 @@ class _IconBuffer(object): else: pixbuf = handle.get_pixbuf() pixbuf = self._get_insensitive_pixbuf(pixbuf, widget) - gdkcontext = gtk.gdk.CairoContext(context) - gdkcontext.set_source_pixbuf(pixbuf, 0, 0) - gdkcontext.paint() + + Gdk.cairo_set_source_pixbuf(context, pixbuf, 0, 0) + context.paint() else: if not sensitive: pixbuf = self._get_insensitive_pixbuf(pixbuf, widget) - gdkcontext = gtk.gdk.CairoContext(context) - gdkcontext.set_source_pixbuf(pixbuf, 0, 0) - gdkcontext.paint() + Gdk.cairo_set_source_pixbuf(context, pixbuf, 0, 0) + context.paint() if self.badge_name: context.restore() @@ -410,20 +405,20 @@ class _IconBuffer(object): xo_color = property(_get_xo_color, _set_xo_color) -class Icon(gtk.Image): +class Icon(Gtk.Image): __gtype_name__ = 'SugarIcon' def __init__(self, **kwargs): self._buffer = _IconBuffer() # HACK: need to keep a reference to the path so it doesn't get garbage - # collected while it's still used if it's a sugar.util.TempFilePath. + # collected while it's still used if it's a sugar3.util.TempFilePath. # See #1175 self._file = None self._alpha = 1.0 self._scale = 1.0 - gobject.GObject.__init__(self, **kwargs) + GObject.GObject.__init__(self, **kwargs) def get_file(self): return self._file @@ -432,7 +427,7 @@ class Icon(gtk.Image): self._file = file_name self._buffer.file_name = file_name - file = gobject.property(type=object, setter=set_file, getter=get_file) + file = GObject.property(type=object, setter=set_file, getter=get_file) def _sync_image_properties(self): if self._buffer.icon_name != self.props.icon_name: @@ -442,7 +437,7 @@ class Icon(gtk.Image): self._buffer.file_name = self.props.file if self.props.pixel_size == -1: - width, height = gtk.icon_size_lookup(self.props.icon_size) + valid_, width, height = Gtk.icon_size_lookup(self.props.icon_size) else: width = height = self.props.pixel_size if self._buffer.width != width or self._buffer.height != height: @@ -458,41 +453,31 @@ class Icon(gtk.Image): def _file_changed_cb(self, image, pspec): self._buffer.file_name = self.props.file - def do_size_request(self, requisition): - """ - Parameters - ---------- - requisition : - - Returns - ------- - None - - """ + def do_get_preferred_height(self): self._sync_image_properties() surface = self._buffer.get_surface() if surface: - requisition[0] = surface.get_width() - requisition[1] = surface.get_height() - elif self._buffer.width and self._buffer.height: - requisition[0] = self._buffer.width - requisition[1] = self._buffer.width + height = surface.get_height() + elif self._buffer.height: + height = self._buffer.height else: - requisition[0] = requisition[1] = 0 - - def do_expose_event(self, event): - """ - Parameters - ---------- - event : + height = 0 + return (height, height) - Returns: - -------- - None + def do_get_preferred_width(self): + self._sync_image_properties() + surface = self._buffer.get_surface() + if surface: + width = surface.get_width() + elif self._buffer.width: + width = self._buffer.width + else: + width = 0 + return (width, width) - """ + def do_draw(self, cr): self._sync_image_properties() - sensitive = (self.state != gtk.STATE_INSENSITIVE) + sensitive = (self.is_sensitive()) surface = self._buffer.get_surface(sensitive, self) if surface is None: return @@ -500,16 +485,14 @@ class Icon(gtk.Image): xpad, ypad = self.get_padding() xalign, yalign = self.get_alignment() requisition = self.get_child_requisition() - if self.get_direction() != gtk.TEXT_DIR_LTR: + if self.get_direction() != Gtk.TextDirection.LTR: xalign = 1.0 - xalign allocation = self.get_allocation() - x = math.floor(allocation.x + xpad + - (allocation.width - requisition[0]) * xalign) - y = math.floor(allocation.y + ypad + - (allocation.height - requisition[1]) * yalign) - - cr = self.window.cairo_create() + x = math.floor(xpad + + (allocation.width - requisition.width) * xalign) + y = math.floor(ypad + + (allocation.height - requisition.height) * yalign) if self._scale != 1.0: cr.scale(self._scale, self._scale) @@ -528,96 +511,36 @@ class Icon(gtk.Image): cr.paint_with_alpha(self._alpha) def set_xo_color(self, value): - """ - Parameters - ---------- - value : - - Returns - ------- - None - - """ if self._buffer.xo_color != value: self._buffer.xo_color = value self.queue_draw() - xo_color = gobject.property( + xo_color = GObject.property( type=object, getter=None, setter=set_xo_color) def set_fill_color(self, value): - """ - Parameters - ---------- - value : - - Returns - ------- - None - - """ if self._buffer.fill_color != value: self._buffer.fill_color = value self.queue_draw() def get_fill_color(self): - """ - Parameters - ---------- - None - - Returns - ------- - fill_color : - - """ return self._buffer.fill_color - fill_color = gobject.property( + fill_color = GObject.property( type=object, getter=get_fill_color, setter=set_fill_color) def set_stroke_color(self, value): - """ - Parameters - ---------- - value : - - Returns - ------- - None - - """ if self._buffer.stroke_color != value: self._buffer.stroke_color = value self.queue_draw() def get_stroke_color(self): - """ - Parameters - ---------- - None - - Returns - ------- - stroke_color : - - """ return self._buffer.stroke_color - stroke_color = gobject.property( + stroke_color = GObject.property( type=object, getter=get_stroke_color, setter=set_stroke_color) def set_badge_name(self, value): - """ - Parameters - ---------- - value: - - Returns - ------- - None - - """ if self._buffer.badge_name != value: self._buffer.badge_name = value self.queue_resize() @@ -625,7 +548,7 @@ class Icon(gtk.Image): def get_badge_name(self): return self._buffer.badge_name - badge_name = gobject.property( + badge_name = GObject.property( type=str, getter=get_badge_name, setter=set_badge_name) def set_alpha(self, value): @@ -633,7 +556,7 @@ class Icon(gtk.Image): self._alpha = value self.queue_draw() - alpha = gobject.property( + alpha = GObject.property( type=float, setter=set_alpha) def set_scale(self, value): @@ -641,19 +564,285 @@ class Icon(gtk.Image): self._scale = value self.queue_draw() - scale = gobject.property( + scale = GObject.property( type=float, setter=set_scale) -class CellRendererIcon(gtk.GenericCellRenderer): +class EventIcon(Gtk.EventBox): + """ + An Icon class that provides access to mouse events and that can act as a + cursor-positioned palette invoker. + """ + + __gtype_name__ = 'SugarEventIcon' + + def __init__(self, **kwargs): + self._buffer = _IconBuffer() + self._alpha = 1.0 + + Gtk.EventBox.__init__(self) + self.set_visible_window(False) + self.set_above_child(True) + self.add_events(Gdk.EventMask.BUTTON_PRESS_MASK | + Gdk.EventMask.TOUCH_MASK | + Gdk.EventMask.BUTTON_RELEASE_MASK) + for key, value in kwargs.iteritems(): + self.set_property(key, value) + + from sugar3.graphics.palette import CursorInvoker + self._palette_invoker = CursorInvoker() + self._palette_invoker.attach(self) + self.connect('destroy', self.__destroy_cb) + + def do_draw(self, cr): + surface = self._buffer.get_surface() + if surface: + allocation = self.get_allocation() + + x = (allocation.width - surface.get_width()) / 2 + y = (allocation.height - surface.get_height()) / 2 + + cr.set_source_surface(surface, x, y) + if self._alpha == 1.0: + cr.paint() + else: + cr.paint_with_alpha(self._alpha) + + def do_get_preferred_height(self): + surface = self._buffer.get_surface() + if surface: + height = surface.get_height() + elif self._buffer.height: + height = self._buffer.height + else: + height = 0 + return (height, height) + + def do_get_preferred_width(self): + surface = self._buffer.get_surface() + if surface: + width = surface.get_width() + elif self._buffer.width: + width = self._buffer.width + else: + width = 0 + return (width, width) + + def __destroy_cb(self, icon): + if self._palette_invoker is not None: + self._palette_invoker.detach() + + def set_file_name(self, value): + if self._buffer.file_name != value: + self._buffer.file_name = value + self.queue_draw() + + def get_file_name(self): + return self._buffer.file_name + + file_name = GObject.property( + type=object, getter=get_file_name, setter=set_file_name) + + def set_icon_name(self, value): + if self._buffer.icon_name != value: + self._buffer.icon_name = value + self.queue_draw() + + def get_icon_name(self): + return self._buffer.icon_name + + icon_name = GObject.property( + type=object, getter=get_icon_name, setter=set_icon_name) + + def set_xo_color(self, value): + if self._buffer.xo_color != value: + self._buffer.xo_color = value + self.queue_draw() + + xo_color = GObject.property( + type=object, getter=None, setter=set_xo_color) + + def set_fill_color(self, value): + if self._buffer.fill_color != value: + self._buffer.fill_color = value + self.queue_draw() + + def get_fill_color(self): + return self._buffer.fill_color + + fill_color = GObject.property( + type=object, getter=get_fill_color, setter=set_fill_color) + + def set_stroke_color(self, value): + if self._buffer.stroke_color != value: + self._buffer.stroke_color = value + self.queue_draw() + + def get_stroke_color(self): + return self._buffer.stroke_color + + stroke_color = GObject.property( + type=object, getter=get_stroke_color, setter=set_stroke_color) + + def set_background_color(self, value): + if self._buffer.background_color != value: + self._buffer.background_color = value + self.queue_draw() + + def get_background_color(self): + return self._buffer.background_color + + background_color = GObject.property( + type=object, getter=get_background_color, setter=set_background_color) + + def set_size(self, value): + if self._buffer.width != value: + self._buffer.width = value + self._buffer.height = value + self.queue_resize() + + def get_size(self): + return self._buffer.width + + pixel_size = GObject.property( + type=object, getter=get_size, setter=set_size) + + def set_scale(self, value): + if self._buffer.scale != value: + self._buffer.scale = value + self.queue_resize() + + def get_scale(self): + return self._buffer.scale + + scale = GObject.property( + type=float, getter=get_scale, setter=set_scale) + + def set_alpha(self, alpha): + if self._alpha != alpha: + self._alpha = alpha + self.queue_draw() + + alpha = GObject.property( + type=float, setter=set_alpha) + + def set_cache(self, value): + self._buffer.cache = value + + def get_cache(self): + return self._buffer.cache + + cache = GObject.property( + type=bool, default=False, getter=get_cache, setter=set_cache) + + def set_badge_name(self, value): + if self._buffer.badge_name != value: + self._buffer.badge_name = value + self.queue_draw() + + def get_badge_name(self): + return self._buffer.badge_name + + badge_name = GObject.property( + type=object, getter=get_badge_name, setter=set_badge_name) + + def create_palette(self): + return None + + def get_palette(self): + return self._palette_invoker.palette + + def set_palette(self, palette): + self._palette_invoker.palette = palette + + palette = GObject.property( + type=object, setter=set_palette, getter=get_palette) + + def get_palette_invoker(self): + return self._palette_invoker + + def set_palette_invoker(self, palette_invoker): + self._palette_invoker.detach() + self._palette_invoker = palette_invoker + + palette_invoker = GObject.property( + type=object, setter=set_palette_invoker, getter=get_palette_invoker) + + def set_tooltip(self, text): + from sugar3.graphics.palette import Palette + + self.set_palette(Palette(text)) + + +class CanvasIcon(EventIcon): + """ + An EventIcon with active and prelight states, and a styleable + background. + + If the icon pops up a palette, the prelight state is set until the + palette pops down. + + """ + + __gtype_name__ = 'SugarCanvasIcon' + + def __init__(self, **kwargs): + EventIcon.__init__(self, **kwargs) + + self.connect('enter-notify-event', self.__enter_notify_event_cb) + self.connect('leave-notify-event', self.__leave_notify_event_cb) + self.connect('button-press-event', self.__button_press_event_cb) + self.connect('button-release-event', self.__button_release_event_cb) + + def connect_to_palette_pop_events(self, palette): + palette.connect('popup', self.__palette_popup_cb) + palette.connect('popdown', self.__palette_popdown_cb) + + def do_draw(self, cr): + """Render a background that fits the allocated space.""" + allocation = self.get_allocation() + context = self.get_style_context() + Gtk.render_background(context, cr, 0, 0, + allocation.width, + allocation.height) + + EventIcon.do_draw(self, cr) + + def __enter_notify_event_cb(self, icon, event): + self.set_state_flags(self.get_state_flags() | Gtk.StateFlags.PRELIGHT, + clear=True) + + def __leave_notify_event_cb(self, icon, event): + if self.palette and self.palette.is_up(): + return + + self.unset_state_flags(Gtk.StateFlags.PRELIGHT) + + def __button_press_event_cb(self, icon, event): + if self.palette and not self.palette.is_up(): + self.set_state_flags(self.get_state_flags() | Gtk.StateFlags.ACTIVE, + clear=True) + + def __button_release_event_cb(self, icon, event): + self.unset_state_flags(Gtk.StateFlags.ACTIVE) + + def __palette_popup_cb(self, palette): + self.set_state_flags(Gtk.StateFlags.PRELIGHT, clear=True) + + def __palette_popdown_cb(self, palette): + self.unset_state_flags(Gtk.StateFlags.PRELIGHT) + + +class CellRendererIcon(Gtk.CellRenderer): __gtype_name__ = 'SugarCellRendererIcon' __gsignals__ = { - 'clicked': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, [object]), + 'clicked': (GObject.SignalFlags.RUN_FIRST, None, [object]), } def __init__(self, tree_view): + #from sugar3.graphics.palette import CellRendererInvoker self._buffer = _IconBuffer() self._buffer.cache = True @@ -662,20 +851,47 @@ class CellRendererIcon(gtk.GenericCellRenderer): self._stroke_color = None self._prelit_fill_color = None self._prelit_stroke_color = None + self._active_state = False + #self._palette_invoker = CellRendererInvoker() + + Gtk.CellRenderer.__init__(self) + + tree_view.connect('button-press-event', + self.__button_press_event_cb) + tree_view.connect('button-release-event', + self.__button_release_event_cb) + + #self._palette_invoker.attach_cell_renderer(tree_view, self) + + def __del__(self): + self._palette_invoker.detach() + + def __button_press_event_cb(self, widget, event): + if self._point_in_cell_renderer(widget, event.x, event.y): + self._active_state = True + + def __button_release_event_cb(self, widget, event): + self._active_state = False + + def create_palette(self): + return None - gobject.GObject.__init__(self) + def get_palette_invoker(self): + return self._palette_invoker + + palette_invoker = GObject.property(type=object, getter=get_palette_invoker) def set_file_name(self, value): if self._buffer.file_name != value: self._buffer.file_name = value - file_name = gobject.property(type=str, setter=set_file_name) + file_name = GObject.property(type=str, setter=set_file_name) def set_icon_name(self, value): if self._buffer.icon_name != value: self._buffer.icon_name = value - icon_name = gobject.property(type=str, setter=set_icon_name) + icon_name = GObject.property(type=str, setter=set_icon_name) def get_xo_color(self): return self._xo_color @@ -683,40 +899,40 @@ class CellRendererIcon(gtk.GenericCellRenderer): def set_xo_color(self, value): self._xo_color = value - xo_color = gobject.property(type=object, + xo_color = GObject.property(type=object, getter=get_xo_color, setter=set_xo_color) def set_fill_color(self, value): if self._fill_color != value: self._fill_color = value - fill_color = gobject.property(type=object, setter=set_fill_color) + fill_color = GObject.property(type=object, setter=set_fill_color) def set_stroke_color(self, value): if self._stroke_color != value: self._stroke_color = value - stroke_color = gobject.property(type=object, setter=set_stroke_color) + stroke_color = GObject.property(type=object, setter=set_stroke_color) def set_prelit_fill_color(self, value): if self._prelit_fill_color != value: self._prelit_fill_color = value - prelit_fill_color = gobject.property(type=object, + prelit_fill_color = GObject.property(type=object, setter=set_prelit_fill_color) def set_prelit_stroke_color(self, value): if self._prelit_stroke_color != value: self._prelit_stroke_color = value - prelit_stroke_color = gobject.property(type=object, + prelit_stroke_color = GObject.property(type=object, setter=set_prelit_stroke_color) def set_background_color(self, value): if self._buffer.background_color != value: self._buffer.background_color = value - background_color = gobject.property(type=object, + background_color = GObject.property(type=object, setter=set_background_color) def set_size(self, value): @@ -724,9 +940,10 @@ class CellRendererIcon(gtk.GenericCellRenderer): self._buffer.width = value self._buffer.height = value - size = gobject.property(type=object, setter=set_size) + size = GObject.property(type=object, setter=set_size) - def on_get_size(self, widget, cell_area): + def do_get_size(self, widget, cell_area, x_offset=None, y_offset=None, + width=None, height=None): width = self._buffer.width + self.props.xpad * 2 height = self._buffer.height + self.props.ypad * 2 xoffset = 0 @@ -734,7 +951,7 @@ class CellRendererIcon(gtk.GenericCellRenderer): if width > 0 and height > 0 and cell_area is not None: - if widget.get_direction() == gtk.TEXT_DIR_RTL: + if widget.get_direction() == Gtk.TextDirection.RTL: xoffset = 1.0 - self.props.xalign else: xoffset = self.props.xalign @@ -744,24 +961,31 @@ class CellRendererIcon(gtk.GenericCellRenderer): return xoffset, yoffset, width, height - def on_activate(self, event, widget, path, background_area, cell_area, + def do_activate(self, event, widget, path, background_area, cell_area, flags): pass - def on_start_editing(self, event, widget, path, background_area, cell_area, + def do_start_editing(self, event, widget, path, background_area, cell_area, flags): pass - def _is_prelit(self, tree_view): - x, y = tree_view.get_pointer() - x, y = tree_view.convert_widget_to_bin_window_coords(x, y) - pos = tree_view.get_path_at_pos(x, y) + def _point_in_cell_renderer(self, tree_view, x=None, y=None): + """Check if the point with coordinates x, y is inside this icon. + + If the x, y coordinates are not given, they are taken from the + pointer current position. + + """ + if x is None and y is None: + x, y = tree_view.get_pointer() + x, y = tree_view.convert_widget_to_bin_window_coords(x, y) + pos = tree_view.get_path_at_pos(int(x), int(y)) if pos is None: return False - path_, column, x, y = pos + path_, column, x, y_ = pos - for cell_renderer in column.get_cell_renderers(): + for cell_renderer in column.get_cells(): if cell_renderer == self: cell_x, cell_width = column.cell_get_position(cell_renderer) if x > cell_x and x < (cell_x + cell_width): @@ -770,8 +994,30 @@ class CellRendererIcon(gtk.GenericCellRenderer): return False - def on_render(self, window, widget, background_area, cell_area, - expose_area, flags): + def do_render(self, cr, widget, background_area, cell_area, flags): + context = widget.get_style_context() + context.save() + context.add_class("sugar-icon-cell") + + pointer_inside = self._point_in_cell_renderer(widget) + + # The context will have prelight state if the mouse pointer is + # in the entire row, but we want that state if the pointer is + # in this cell only: + if flags & Gtk.CellRendererState.PRELIT: + if pointer_inside: + if self._active_state: + context.set_state(Gtk.StateFlags.ACTIVE) + else: + context.set_state(Gtk.StateFlags.NORMAL) + + + Gtk.render_background(context, cr, background_area.x, background_area.y, + background_area.width, background_area.height) + + Gtk.render_frame(context, cr, background_area.x, background_area.y, + background_area.width, background_area.height) + if self._xo_color is not None: stroke_color = self._xo_color.get_stroke_color() fill_color = self._xo_color.get_fill_color() @@ -786,8 +1032,8 @@ class CellRendererIcon(gtk.GenericCellRenderer): has_prelit_colors = None not in [prelit_fill_color, prelit_stroke_color] - if flags & gtk.CELL_RENDERER_PRELIT and has_prelit_colors and \ - self._is_prelit(widget): + if flags & Gtk.CellRendererState.PRELIT and has_prelit_colors and \ + pointer_inside: self._buffer.fill_color = prelit_fill_color self._buffer.stroke_color = prelit_stroke_color @@ -799,20 +1045,21 @@ class CellRendererIcon(gtk.GenericCellRenderer): if surface is None: return - xoffset, yoffset, width_, height_ = self.on_get_size(widget, cell_area) + xoffset, yoffset, width_, height_ = self.do_get_size(widget, cell_area) x = cell_area.x + xoffset y = cell_area.y + yoffset - cr = window.cairo_create() cr.set_source_surface(surface, math.floor(x), math.floor(y)) - cr.rectangle(expose_area) + cr.rectangle(cell_area.x, cell_area.y, cell_area.width, + cell_area.height) + cr.clip() cr.paint() def get_icon_state(base_name, perc, step=5): strength = round(perc / step) * step - icon_theme = gtk.icon_theme_get_default() + icon_theme = Gtk.IconTheme.get_default() while strength <= 100 and strength >= 0: icon_name = '%s-%03d' % (base_name, strength) @@ -823,8 +1070,8 @@ def get_icon_state(base_name, perc, step=5): def get_icon_file_name(icon_name): - icon_theme = gtk.icon_theme_get_default() - info = icon_theme.lookup_icon(icon_name, gtk.ICON_SIZE_LARGE_TOOLBAR, 0) + icon_theme = Gtk.IconTheme.get_default() + info = icon_theme.lookup_icon(icon_name, Gtk.IconSize.LARGE_TOOLBAR, 0) if not info: return None filename = info.get_filename() |