diff --git a/shell/view/home/activitiesdonut.py b/shell/view/home/activitiesdonut.py index 4796a376..2359a32f 100644 --- a/shell/view/home/activitiesdonut.py +++ b/shell/view/home/activitiesdonut.py @@ -18,7 +18,6 @@ import hippo import math import gobject import colorsys -import logging from sugar.graphics.canvasicon import CanvasIcon from sugar.graphics import style @@ -45,19 +44,19 @@ def html_to_rgb(html_color): return (r, g, b) class ActivityIcon(CanvasIcon): - _LEVEL_MAX = 1.6 - _LEVEL_MIN = 0.0 - _INTERVAL = 100 + _INTERVAL = 150 def __init__(self, activity): icon_name = activity.get_icon_name() self._orig_color = profile.get_color() - - self._direction = 0 - self._level = self._LEVEL_MAX - color = self._get_icon_color_for_level() + self._icon_colors = self._compute_icon_colors() - CanvasIcon.__init__(self, icon_name=icon_name, color=color) + self._direction = 0 + self._level_max = len(self._icon_colors) - 1 + self._level = self._level_max + color = self._icon_colors[self._level] + + CanvasIcon.__init__(self, icon_name=icon_name, color=color, cache=True) style.apply_stylesheet(self, 'ring.ActivityIcon') self._activity = activity @@ -68,32 +67,44 @@ class ActivityIcon(CanvasIcon): self.cleanup() def cleanup(self): - logging.debug("removing source %s" % self._pulse_id) if self._pulse_id > 0: gobject.source_remove(self._pulse_id) self._pulse_id = 0 + # dispose of all rendered icons from launch feedback + self._clear_buffers() - def _get_icon_color_for_level(self): - factor = math.sin(self._level) + def _compute_icon_colors(self): + _LEVEL_MAX = 1.6 + _LEVEL_STEP = 0.16 + _LEVEL_MIN = 0.0 + icon_colors = {} + level = _LEVEL_MIN + for i in range(0, int(_LEVEL_MAX / _LEVEL_STEP)): + icon_colors[i] = self._get_icon_color_for_level(level) + level += _LEVEL_STEP + return icon_colors + + def _get_icon_color_for_level(self, level): + factor = math.sin(level) h, s, v = colorsys.rgb_to_hsv(*html_to_rgb(self._orig_color.get_fill_color())) new_fill = rgb_to_html(*colorsys.hsv_to_rgb(h, s * factor, v)) h, s, v = colorsys.rgb_to_hsv(*html_to_rgb(self._orig_color.get_stroke_color())) new_stroke = rgb_to_html(*colorsys.hsv_to_rgb(h, s * factor, v)) - return iconcolor.IconColor("%s,%s" % (new_fill, new_stroke)) + return iconcolor.IconColor("%s,%s" % (new_stroke, new_fill)) def _pulse_cb(self): if self._direction == 1: - self._level += 0.1 - if self._level >= self._LEVEL_MAX: + self._level += 1 + if self._level > self._level_max: self._direction = 0 - self._level = self._LEVEL_MAX + self._level = self._level_max elif self._direction == 0: - self._level -= 0.1 - if self._level <= self._LEVEL_MIN: + self._level -= 1 + if self._level <= 0: self._direction = 1 - self._level = self._LEVEL_MIN + self._level = 0 - self.props.color = self._get_icon_color_for_level() + self.props.color = self._icon_colors[self._level] self.emit_paint_needed(0, 0, -1, -1) return True diff --git a/sugar/graphics/canvasicon.py b/sugar/graphics/canvasicon.py index 05d3b212..2b38489a 100644 --- a/sugar/graphics/canvasicon.py +++ b/sugar/graphics/canvasicon.py @@ -16,65 +16,113 @@ # Boston, MA 02111-1307, USA. import re -import logging import gobject import gtk import hippo import rsvg import cairo +import time from sugar.graphics.iconcolor import IconColor -class _IconCache: - def __init__(self): - self._icons = {} - self._theme = gtk.icon_theme_get_default() +class _IconCacheIcon: + def __init__(self, name, color, now): + self.data_size = None + self.handle = self._read_icon_data(name, color) + self.last_used = now + self.usage_count = 1 - def _read_icon(self, filename, color): + def _read_icon_data(self, filename, color): icon_file = open(filename, 'r') + data = icon_file.read() + icon_file.close() - if color == None: - return rsvg.Handle(file=filename) - else: - data = icon_file.read() - icon_file.close() - + if color: fill = color.get_fill_color() stroke = color.get_stroke_color() - + entity = '' % fill data = re.sub('', entity, data) entity = '' % stroke data = re.sub('', entity, data) - return rsvg.Handle(data=data) + self.data_size = len(data) + return rsvg.Handle(data=data) + +class _IconCache: + _CACHE_MAX = 50000 # in bytes + + def __init__(self): + self._icons = {} + self._theme = gtk.icon_theme_get_default() + self._cache_size = 0 + + def _get_real_name_from_theme(self, name, size): + info = self._theme.lookup_icon(name, size, 0) + if not info: + raise ValueError("Icon '" + name + "' not found.") + fname = info.get_filename() + del info + return fname + + def _cache_cleanup(self, key, now): + while self._cache_size > self._CACHE_MAX: + evict_key = None + oldest_key = None + oldest_time = now + for icon_key, icon in self._icons.items(): + # Don't evict the icon we are about to use if it's in the cache + if icon_key == key: + continue + + # evict large icons first + if icon.data_size > self._CACHE_MAX: + evict_key = icon_key + break + # evict older icons next; those used over 2 minutes ago + if icon.last_used < now - 120: + evict_key = icon_key + break + # otherwise, evict the oldest + if oldest_time > icon.last_used: + oldest_time = icon.last_used + oldest_key = icon_key + + # If there's nothing specific to evict, try evicting + # the oldest thing + if not evict_key: + if not oldest_key: + break + evict_key = oldest_key + + self._cache_size -= self._icons[evict_key].data_size + del self._icons[evict_key] def get_handle(self, name, color, size): if name[0:6] == "theme:": - icon = self._read_icon_from_name(name[6:], color, size) - else: - icon = self._read_icon(name, color) - return icon - - def _read_icon_from_name(self, name, color, size): - info = self._theme.lookup_icon(name, size, 0) - - if not info: - raise "Icon '" + name + "' not found." + name = self._get_real_name_from_theme(name[6:], size) if color: - key = (info.get_filename(), color.to_string()) + key = (name, color.to_string()) else: - key = info.get_filename() + key = name + + # If we're over the cache limit, evict something from the cache + now = time.time() + self._cache_cleanup(key, now) if self._icons.has_key(key): icon = self._icons[key] + icon.usage_count += 1 + icon.last_used = now else: - icon = self._read_icon(info.get_filename(), color) + icon = _IconCacheIcon(name, color, now) self._icons[key] = icon - return icon + self._cache_size += icon.data_size + return icon.handle + class CanvasIcon(hippo.CanvasBox, hippo.CanvasItem): __gtype_name__ = 'CanvasIcon' @@ -86,39 +134,48 @@ class CanvasIcon(hippo.CanvasBox, hippo.CanvasItem): gobject.PARAM_READWRITE), 'size' : (int, None, None, 0, 1024, 24, + gobject.PARAM_READWRITE), + 'cache' : (bool, None, None, False, gobject.PARAM_READWRITE) } _cache = _IconCache() def __init__(self, **kwargs): - self._buffer = None + self._buffers = {} + self._cur_buffer = None self._size = 24 self._color = None self._icon_name = None + self._cache = False hippo.CanvasBox.__init__(self, **kwargs) self.connect('button-press-event', self._button_press_event_cb) - def _invalidate_buffer(self, new_buffer): - if self._buffer: - del self._buffer - self._buffer = new_buffer + def _clear_buffers(self): + for key in self._buffers.keys(): + del self._buffers[key] + self._buffers = {} def do_set_property(self, pspec, value): if pspec.name == 'icon-name': + if self._icon_name != value and not self._cache: + self._clear_buffers() self._icon_name = value - self._invalidate_buffer(None) self.emit_paint_needed(0, 0, -1, -1) elif pspec.name == 'color': - self._invalidate_buffer(None) + if self._color != value and not self._cache: + self._clear_buffers() self._color = value self.emit_paint_needed(0, 0, -1, -1) elif pspec.name == 'size': - self._invalidate_buffer(None) + if self._size != value and not self._cache: + self._clear_buffers() self._size = value self.emit_request_changed() + elif pspec.name == 'cache': + self._cache = value def do_get_property(self, pspec): if pspec.name == 'size': @@ -127,33 +184,39 @@ class CanvasIcon(hippo.CanvasBox, hippo.CanvasItem): return self._icon_name elif pspec.name == 'color': return self._color + elif pspec.name == 'cache': + return self._cache - def _get_buffer(self, cr, handle, size): - if self._buffer == None: + def _get_buffer(self, cr, handle): + key = (self._icon_name, self._color, self._size) + + buf = None + if self._buffers.has_key(key): + buf = self._buffers[key] + else: target = cr.get_target() - surface = target.create_similar(cairo.CONTENT_COLOR_ALPHA, - int(size) + 1, int(size) + 1) + size = int(self._size) + 1 + buf = target.create_similar(cairo.CONTENT_COLOR_ALPHA, size, size) dimensions = handle.get_dimension_data() scale = float(size) / float(dimensions[0]) - ctx = cairo.Context(surface) + ctx = cairo.Context(buf) ctx.scale(scale, scale) handle.render_cairo(ctx) del ctx + self._buffers[key] = buf - self._buffer = surface - - return self._buffer + return buf def do_paint_below_children(self, cr, damaged_box): icon_name = self._icon_name if icon_name == None: - icon_name = 'stock-missing' + icon_name = 'theme:stock-missing' handle = CanvasIcon._cache.get_handle( icon_name, self._color, self._size) - buf = self._get_buffer(cr, handle, self._size) + buf = self._get_buffer(cr, handle) [width, height] = self.get_allocation() x = (width - self._size) / 2