Merge branch 'master' of git+ssh://j5@dev.laptop.org/git/sugar

19 files changed, 654 insertions, 581 deletions

diff --git a/sugar/activity/activity.py b/sugar/activity/activity.py
index ccc8b90..6655b24 100644
--- a/sugar/activity/activity.py
+++ b/sugar/activity/activity.py
@@ -75,9 +75,9 @@ class ActivityToolbar(gtk.Toolbar):
         self.share = ToolComboBox(label_text='Share with:')
         self.share.combo.connect('changed', self._share_changed_cb)
         self.share.combo.append_item(None, _('Private'),
-                                     'theme:zoom-home-mini')
+                                     'zoom-home-mini')
         self.share.combo.append_item(None, _('My Neighborhood'),
-                                     'theme:zoom-neighborhood-mini')
+                                     'zoom-neighborhood-mini')
         self.insert(self.share, -1)
         self.share.show()
 
@@ -469,13 +469,22 @@ class Activity(Window, gtk.Container):
         self._shared_activity = activity
         self.emit('shared')
 
-    def share(self):
-        """Request that the activity be shared on the network."""
+    def share(self, private=False):
+        """Request that the activity be shared on the network.
+        
+        private -- bool: True to share by invitation only,
+            False to advertise as shared to everyone.
+        """
+        # FIXME: Make private=True to turn on the by-invitation-only scope
         if self._shared_activity and self._shared_activity.props.joined:
-            raise RuntimeError("Activity %s already shared." % self._activity_id)
-        logging.debug('Requesting share of activity %s.' % self._activity_id)
-        self._share_id = self._pservice.connect("activity-shared", self._internal_share_cb)
-        self._pservice.share_activity(self)
+            raise RuntimeError("Activity %s already shared." %
+                               self._activity_id)
+        verb = private and 'private' or 'public'
+        logging.debug('Requesting %s share of activity %s.' %
+                      (verb, self._activity_id))
+        self._share_id = self._pservice.connect("activity-shared", 
+                                                self._internal_share_cb)
+        self._pservice.share_activity(self, private=private)
 
     def _realize_cb(self, window):
         wm.set_bundle_id(window.window, self.get_service_name())
diff --git a/sugar/activity/activityfactory.py b/sugar/activity/activityfactory.py
index 404e5f4..d7d6d92 100644
--- a/sugar/activity/activityfactory.py
+++ b/sugar/activity/activityfactory.py
@@ -26,12 +26,18 @@ from sugar.presence import presenceservice
 from sugar.activity.activityhandle import ActivityHandle
 from sugar import util
 
+import os
+
 _SHELL_SERVICE = "org.laptop.Shell"
 _SHELL_PATH = "/org/laptop/Shell"
 _SHELL_IFACE = "org.laptop.Shell"
 
 _ACTIVITY_FACTORY_INTERFACE = "org.laptop.ActivityFactory"
 
+_RAINBOW_SERVICE_NAME = "org.laptop.security.Rainbow"
+_RAINBOW_ACTIVITY_FACTORY_PATH = "/"
+_RAINBOW_ACTIVITY_FACTORY_INTERFACE = "org.laptop.security.Rainbow"
+
 def create_activity_id():
     """Generate a new, unique ID for this activity"""
     pservice = presenceservice.get_instance()
@@ -84,6 +90,9 @@ class ActivityCreationHandler(gobject.GObject):
         particular type of activity is created during the activity
         registration process in shell bundle registry which creates 
         service definition files for each registered bundle type.
+
+        If the file '/etc/olpc-security' exists, then activity launching
+        will be delegated to the prototype 'Rainbow' security service.
         """
         gobject.GObject.__init__(self)
         self._service_name = service_name
@@ -112,10 +121,22 @@ class ActivityCreationHandler(gobject.GObject):
                     reply_handler=self._no_reply_handler,
                     error_handler=self._notify_launch_error_handler)
 
-        self._factory.create(self._activity_handle.get_dict(),
-                             timeout=120 * 1000,
-                             reply_handler=self._no_reply_handler,
-                             error_handler=self._create_error_handler)
+        if not os.path.exists('/etc/olpc-security'):
+            self._factory.create(self._activity_handle.get_dict(),
+                                 timeout=120 * 1000,
+                                 reply_handler=self._no_reply_handler,
+                                 error_handler=self._create_error_handler)
+        else:
+            system_bus = dbus.SystemBus()
+            factory = system_bus.get_object(_RAINBOW_SERVICE_NAME,
+                                            _RAINBOW_ACTIVITY_FACTORY_PATH)
+            factory.CreateActivity(
+                    self._service_name,
+                    self._activity_handle.get_dict(),
+                    timeout=120 * 1000,
+                    reply_handler=self._create_reply_handler,
+                    error_handler=self._create_error_handler,
+                    dbus_interface=_RAINBOW_ACTIVITY_FACTORY_INTERFACE)
 
     def get_activity_id(self):
         """Retrieve the unique identity for this activity"""
diff --git a/sugar/datastore/datastore.py b/sugar/datastore/datastore.py
index 7af2e93..1fe9cc3 100644
--- a/sugar/datastore/datastore.py
+++ b/sugar/datastore/datastore.py
@@ -63,6 +63,9 @@ class DSMetadata(gobject.GObject):
     def get_dictionary(self):
         return self._props
 
+    def copy(self):
+        return DSMetadata(self._props.copy())
+
 class DSObject(object):
     def __init__(self, object_id, metadata=None, file_path=None):
         self.object_id = object_id
@@ -161,6 +164,9 @@ class DSObject(object):
                             'Please call DSObject.destroy() before disposing it.')
             self.destroy()
 
+    def copy(self):
+        return DSObject(None, self._metadata.copy(), self._file_path)
+
 def get(object_id):
     logging.debug('datastore.get')
     metadata = dbus_helpers.get_properties(object_id)
@@ -224,6 +230,16 @@ def find(query, sorting=None, limit=None, offset=None, reply_handler=None,
 
     return objects, total_count
 
+def copy(jobject, mount_point):
+
+    new_jobject = jobject.copy()
+    new_jobject.metadata['mountpoint'] = mount_point
+
+    # this will cause the file be retrieved from the DS
+    new_jobject.file_path = jobject.file_path
+
+    write(new_jobject)
+
 def mount(uri, options):
     return dbus_helpers.mount(uri, options)
 
diff --git a/sugar/graphics/Makefile.am b/sugar/graphics/Makefile.am
index 7fb63dc..8911b68 100644
--- a/sugar/graphics/Makefile.am
+++ b/sugar/graphics/Makefile.am
@@ -2,11 +2,9 @@ sugardir = $(pythondir)/sugar/graphics
 sugar_PYTHON =			\
 	__init__.py		\
 	animator.py		\
-	canvasbutton.py		\
-	canvasicon.py		\
-	canvasentry.py		\
-	canvasroundbox.py	\
+	button.py		\
 	combobox.py		\
+	entry.py		\
 	icon.py			\
 	iconbutton.py          	\
 	iconentry.py          	\
@@ -17,6 +15,7 @@ sugar_PYTHON =			\
 	palette.py		\
 	palettegroup.py		\
 	panel.py		\
+	roundbox.py		\
 	spreadlayout.py		\
 	style.py		\
 	toggletoolbutton.py	\
diff --git a/sugar/graphics/canvasbutton.py b/sugar/graphics/button.py
index fc869f9..647f36d 100644
--- a/sugar/graphics/canvasbutton.py
+++ b/sugar/graphics/button.py
@@ -25,7 +25,7 @@ class CanvasButton(hippo.CanvasButton):
         hippo.CanvasButton.__init__(self, text=label)
 
         if icon_name:
-            icon = Icon(icon_name,icon_size=gtk.ICON_SIZE_BUTTON)
+            icon = Icon(icon_name=icon_name, icon_size=gtk.ICON_SIZE_BUTTON)
             self.props.widget.set_image(icon)
             icon.show()
 
diff --git a/sugar/graphics/canvasicon.py b/sugar/graphics/canvasicon.py
deleted file mode 100644
index 3632551..0000000
--- a/sugar/graphics/canvasicon.py
+++ /dev/null
@@ -1,433 +0,0 @@
-# Copyright (C) 2006-2007 Red Hat, Inc.
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2 of the License, or (at your option) any later version.
-#
-# This library 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
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the
-# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-# Boston, MA 02111-1307, USA.
-
-import logging
-import re
-
-import gobject
-import gtk
-import hippo
-import rsvg
-import cairo
-import time
-
-from sugar.graphics.xocolor import XoColor
-from sugar.graphics import style
-from sugar.graphics.palette import Palette, CanvasInvoker
-
-_ICON_REQUEST_SIZE = 50
-_BADGE_SIZE = 0.45
-
-class _IconCacheIcon:
-    def __init__(self, name, fill_color, stroke_color, now):
-        self.last_used = now
-        self.usage_count = 1
-        self.badge_x = 1.0 - _BADGE_SIZE / 2
-        self.badge_y = 1.0 - _BADGE_SIZE / 2
-
-        if name[0:6] == "theme:": 
-            info = gtk.icon_theme_get_default().lookup_icon(
-                name[6:], _ICON_REQUEST_SIZE, 0)
-            if not info:
-                raise ValueError("Icon '" + name + "' not found.")
-
-            fname = info.get_filename()
-            attach_points = info.get_attach_points()
-            if attach_points is not None:
-                self.badge_x = float(attach_points[0][0]) / _ICON_REQUEST_SIZE
-                self.badge_y = float(attach_points[0][1]) / _ICON_REQUEST_SIZE
-            del info
-        else:
-            fname = name
-
-        self.handle = self._read_icon_data(fname, fill_color, stroke_color)
-
-    def _read_icon_data(self, filename, fill_color, stroke_color):
-        icon_file = open(filename, 'r')
-        data = icon_file.read()
-        icon_file.close()
-
-        if fill_color:
-            entity = '<!ENTITY fill_color "%s">' % fill_color
-            data = re.sub('<!ENTITY fill_color .*>', entity, data)
-
-        if stroke_color:
-            entity = '<!ENTITY stroke_color "%s">' % stroke_color
-            data = re.sub('<!ENTITY stroke_color .*>', entity, data)
-
-        self.data_size = len(data)
-        return rsvg.Handle(data=data)
-
-class _IconCache:
-    _CACHE_MAX = 50000   # in bytes
-
-    def __init__(self):
-        self._icons = {}
-        self._cache_size = 0
-
-    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_icon(self, name, fill_color, stroke_color):
-        if not name:
-            return None
-
-        if fill_color or stroke_color:
-            key = (name, fill_color, stroke_color)
-        else:
-            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 = _IconCacheIcon(name, fill_color, stroke_color, now)
-            self._icons[key] = icon
-            self._cache_size += icon.data_size
-        return icon
-
-
-class CanvasIcon(hippo.CanvasBox, hippo.CanvasItem):
-    __gtype_name__ = 'CanvasIcon'
-
-    __gproperties__ = {
-        'icon-name'     : (str, None, None, None,
-                           gobject.PARAM_READWRITE),
-        'xo-color'      : (object, None, None,
-                           gobject.PARAM_WRITABLE),
-        'fill-color'    : (object, None, None,
-                           gobject.PARAM_READWRITE),
-        'stroke-color'  : (object, None, None,
-                           gobject.PARAM_READWRITE),
-        'size'          : (int, None, None, 0, 1024, 0,
-                           gobject.PARAM_READWRITE),
-        'scale'         : (int, None, None, 0, 1024, 0,
-                           gobject.PARAM_READWRITE),
-        'cache'         : (bool, None, None, False,
-                           gobject.PARAM_READWRITE),
-        'active'        : (bool, None, None, True,
-                           gobject.PARAM_READWRITE),
-        'badge-name'    : (str, None, None, None,
-                           gobject.PARAM_READWRITE)
-    }
-
-    _cache = _IconCache()
-
-    def __init__(self, **kwargs):
-        self._buffers = {}
-        self._cur_buffer = None
-        self._size = 0
-        self._scale = 0
-        self._fill_color = None
-        self._stroke_color = None
-        self._icon_name = None
-        self._cache = False
-        self._icon = None
-        self._active = True
-        self._palette = None
-        self._badge_name = None
-        self._badge_icon = None
-
-        hippo.CanvasBox.__init__(self, **kwargs)
-        
-        self.connect_after('motion-notify-event', self._motion_notify_event_cb)
-
-    def _clear_buffers(self):
-        icon_key = self._get_current_buffer_key(self._icon_name)
-        badge_key = None
-        if self._badge_name:
-            badge_key = self._get_current_buffer_key(self._badge_name)
-        for key in self._buffers.keys():
-            if key != icon_key:
-                if not badge_key or (key != badge_key):
-                    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._icon = None
-            self.emit_paint_needed(0, 0, -1, -1)
-        elif pspec.name == 'xo-color':
-            self.props.fill_color = style.Color(value.get_fill_color())
-            self.props.stroke_color = style.Color(value.get_stroke_color())
-        elif pspec.name == 'fill-color':
-            if self._fill_color != value:
-                if not self._cache:
-                    self._clear_buffers()
-                self._fill_color = value
-                self._icon = None
-                self._badge_icon = None
-                self.emit_paint_needed(0, 0, -1, -1)
-        elif pspec.name == 'stroke-color':
-            if self._stroke_color != value:
-                if not self._cache:
-                    self._clear_buffers()
-                self._stroke_color = value
-                self._icon = None
-                self._badge_icon = None
-                self.emit_paint_needed(0, 0, -1, -1)
-        elif pspec.name == 'size':
-            if self._size != value and not self._cache:
-                self._clear_buffers()
-            self._size = value
-            self.emit_request_changed()
-        elif pspec.name == 'scale':
-            if self._scale != value and not self._cache:
-                self._clear_buffers()
-            self._scale = value
-            self.emit_request_changed()
-        elif pspec.name == 'cache':
-            self._cache = value
-        elif pspec.name == 'active':
-            if self._active != value:
-                if not self._cache:
-                    self._clear_buffers()
-                self._active = value
-                self._icon = None
-                self.emit_paint_needed(0, 0, -1, -1)
-        elif pspec.name == 'badge-name':
-            if self._badge_name != value and not self._cache:
-                self._clear_buffers()
-            self._badge_name = value
-            self._badge_icon = None
-            self.emit_paint_needed(0, 0, -1, -1)
-
-    def _choose_colors(self):
-        fill_color = None
-        stroke_color = None
-        if self._active:
-            if self._fill_color:
-                fill_color = self._fill_color.get_svg()
-            if self._stroke_color:
-                stroke_color = self._stroke_color.get_svg()
-        else:
-            stroke_color = color.ICON_STROKE_INACTIVE.get_svg()
-            if self._fill_color:
-                fill_color = self._fill_color.get_svg()
-        return [fill_color, stroke_color]
-
-    def _get_icon_from_cache(self, name, icon):
-        if not icon:
-            cache = CanvasIcon._cache
-
-            [fill_color, stroke_color] = self._choose_colors()
-
-            icon = cache.get_icon(name, fill_color, stroke_color)
-        return icon
-
-    def _get_icon(self):
-        self._icon = self._get_icon_from_cache(self._icon_name, self._icon)
-        return self._icon
-
-    def _get_badge_icon(self):
-        self._badge_icon = self._get_icon_from_cache(self._badge_name,
-                                                     self._badge_icon)
-        return self._badge_icon
-
-    def _get_current_buffer_key(self, name):
-        [fill_color, stroke_color] = self._choose_colors()
-        return (name, fill_color, stroke_color, self._size)
-
-    def do_get_property(self, pspec):
-        if pspec.name == 'size':
-            return self._size
-        elif pspec.name == 'icon-name':
-            return self._icon_name
-        elif pspec.name == 'fill-color':
-            return self._fill_color
-        elif pspec.name == 'stroke-color':
-            return self._stroke_color
-        elif pspec.name == 'cache':
-            return self._cache
-        elif pspec.name == 'active':
-            return self._active
-        elif pspec.name == 'badge-name':
-            return self._badge_name
-        elif pspec.name == 'scale':
-            return self._scale
-
-    def _get_icon_size(self, icon):
-        if icon:
-            dimensions = icon.handle.get_dimension_data()
-            return int(dimensions[0]), int(dimensions[1])
-        else:
-            return [0, 0]
-
-    def _get_size(self, icon):
-        width, height = self._get_icon_size(icon)
-        if self._scale != 0:
-            width = int(width * self._scale)
-            height = int(height * self._scale)
-        elif self._size != 0:
-            width = height = self._size
-
-        return [width, height]
-
-    def _get_buffer(self, cr, name, icon, scale_factor=None):
-        """Return a cached cairo surface for the SVG icon, or if none exists,
-        create a new cairo surface with the right size."""
-        buf = None
-
-        key = self._get_current_buffer_key(name)
-        if self._buffers.has_key(key):
-            buf = self._buffers[key]
-        else:
-            [icon_w, icon_h] = self._get_icon_size(icon)
-            [target_w, target_h] = self._get_size(icon)
-
-            if scale_factor:
-                target_w = int(target_w * scale_factor)
-                target_h = int(target_h * scale_factor)
-
-            target = cr.get_target()
-            buf = target.create_similar(cairo.CONTENT_COLOR_ALPHA,
-                                        target_w, target_h)
-            ctx = cairo.Context(buf)
-            ctx.scale(float(target_w) / float(icon_w),
-                      float(target_h) / float(icon_h))
-            icon.handle.render_cairo(ctx)
-
-            del ctx
-            self._buffers[key] = buf
-
-        return buf
-
-    def do_paint_below_children(self, cr, damaged_box):
-        icon = self._get_icon()
-        if icon is None:
-            return
-
-        icon_buf = self._get_buffer(cr, self._icon_name, icon)
-        [width, height] = self.get_allocation()
-        icon_x = (width - icon_buf.get_width()) / 2
-        icon_y = (height - icon_buf.get_height()) / 2
-
-        cr.set_source_surface(icon_buf, icon_x, icon_y)
-        cr.paint()
-
-        if self._badge_name:
-            badge_icon = self._get_badge_icon()
-            if badge_icon:
-                badge_buf = self._get_buffer(cr, self._badge_name, badge_icon, _BADGE_SIZE)
-                badge_x = (icon_x + icon.badge_x * icon_buf.get_width() -
-                           badge_buf.get_width() / 2)
-                badge_y = (icon_y + icon.badge_y * icon_buf.get_height() -
-                           badge_buf.get_height() / 2)
-                cr.set_source_surface(badge_buf, badge_x, badge_y)
-                cr.paint()
-
-    def do_get_content_width_request(self):
-        icon = self._get_icon()
-        [width, height] = self._get_size(icon)
-        if self._badge_name is not None:
-            # If the badge goes outside the bounding box, add space
-            # on *both* sides (to keep the main icon centered)
-            if icon.badge_x < 0.0:
-                width = int(width * 2 * (1.0 - icon.badge_x))
-            elif icon.badge_x + _BADGE_SIZE > 1.0:
-                width = int(width * 2 * (icon.badge_x + _BADGE_SIZE - 1.0))
-        return (width, width)
-
-    def do_get_content_height_request(self, for_width):
-        icon = self._get_icon()
-        [width, height] = self._get_size(icon)
-        if self._badge_name is not None:
-            if icon.badge_y < 0.0:
-                height = int(height * 2 * (1.0 - icon.badge_y))
-            elif icon.badge_y + _BADGE_SIZE > 1.0:
-                height = int(height * 2 * (icon.badge_y + _BADGE_SIZE - 1.0))
-        return (height, height)
-
-    def do_button_press_event(self, event):
-        self.emit_activated()
-        return True
-
-    def _motion_notify_event_cb(self, button, event):
-        if event.detail == hippo.MOTION_DETAIL_ENTER:
-            self.prelight(True)
-        elif event.detail == hippo.MOTION_DETAIL_LEAVE:
-            self.prelight(False)
-        return False
-
-    def prelight(self, enter):
-        """
-        Override this method for adding prelighting behavior.
-        """
-        pass
-
-    def get_palette(self):
-        return self._palette
-    
-    def set_palette(self, palette):
-        self._palette = palette
-        if not self._palette.props.invoker:
-            self._palette.props.invoker = CanvasInvoker(self)
-
-    def set_tooltip(self, text):
-        self.set_palette(Palette(text))
-    
-    palette = property(get_palette, set_palette)
-
-def get_icon_state(base_name, perc):
-        step = 5
-        strength = round(perc / step) * step
-        icon_theme = gtk.icon_theme_get_default()
-
-        while strength <= 100:
-            icon_name = '%s-%03d' % (base_name, strength)
-            if icon_theme.has_icon(icon_name):
-                return 'theme:' + icon_name
-
-            strength = strength + step
diff --git a/sugar/graphics/combobox.py b/sugar/graphics/combobox.py
index 3251dc2..5584267 100644
--- a/sugar/graphics/combobox.py
+++ b/sugar/graphics/combobox.py
@@ -61,8 +61,8 @@ class ComboBox(gtk.ComboBox):
         del info
         return fname
 
-    def append_item(self, action_id, text, icon_name=None):
-        if not self._icon_renderer and icon_name:
+    def append_item(self, action_id, text, icon_name=None, file_name=None):
+        if not self._icon_renderer and (icon_name or file_name):
             self._icon_renderer = gtk.CellRendererPixbuf()
 
             settings = self.get_settings()
@@ -77,16 +77,17 @@ class ComboBox(gtk.ComboBox):
             self.pack_end(self._text_renderer, True)
             self.add_attribute(self._text_renderer, 'text', 1)
 
-        if icon_name:
+        if icon_name or file_name:
             if text:
                 size = gtk.ICON_SIZE_MENU
             else:
                 size = gtk.ICON_SIZE_LARGE_TOOLBAR
-
             width, height = gtk.icon_size_lookup(size)
-            if icon_name[0:6] == "theme:": 
-                icon_name = self._get_real_name_from_theme(icon_name[6:], size)
-            pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(icon_name, width, height)
+
+            if icon_name:
+                file_name = self._get_real_name_from_theme(icon_name, size)
+
+            pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(file_name, width, height)
         else:
             pixbuf = None
 
diff --git a/sugar/graphics/canvasentry.py b/sugar/graphics/entry.py
index 95510e5..95510e5 100644
--- a/sugar/graphics/canvasentry.py
+++ b/sugar/graphics/entry.py
diff --git a/sugar/graphics/icon.py b/sugar/graphics/icon.py
index ff4e09a..6d7a4c6 100644
--- a/sugar/graphics/icon.py
+++ b/sugar/graphics/icon.py
@@ -16,11 +16,280 @@
 # Boston, MA 02111-1307, USA.
 
 import os
+import re
+import time
+import logging
+
 import gobject
 import gtk
-import re
+import hippo
+import rsvg
+import cairo
 
 from sugar.graphics.style import Color
+from sugar.graphics.xocolor import XoColor
+from sugar.graphics import style
+from sugar.graphics.palette import Palette, CanvasInvoker
+
+_BADGE_SIZE = 0.45
+
+_svg_loader = None
+
+def _get_svg_loader():
+    global _svg_loader
+    if _svg_loader == None:
+        _svg_loader = _SVGLoader()
+    return _svg_loader
+
+class _SVGIcon(object):
+    def __init__(self, data):
+        self.data = data
+        self.data_size = len(data)
+        self.last_used = time.time()
+
+class _SVGLoader(object):
+    CACHE_MAX_SIZE = 50000
+    CACHE_MAX_ICON_SIZE = 5000
+
+    def __init__(self):
+        self._cache = {}
+        self._cache_size = 0
+
+    def load(self, file_name, entities):
+        icon = self._get_icon(file_name)
+
+        for entity, value in entities.items():
+            xml = '<!ENTITY %s "%s">' % (entity, value)
+            icon.data = re.sub('<!ENTITY %s .*>' % entity, xml, icon.data)
+
+        return rsvg.Handle(data=icon.data)
+
+    def _get_icon(self, file_name):
+        if self._cache.has_key(file_name):
+            data = self._cache[file_name]
+            data.last_used = time.time()
+            return data
+
+        icon_file = open(file_name, 'r')
+        icon = _SVGIcon(icon_file.read())
+        icon_file.close()
+
+        self._cache[file_name] = icon
+        self._cleanup_cache()
+
+        return icon
+
+    def _cleanup_cache(self):
+        now = time.time()
+        while self._cache_size > self.CACHE_MAX_SIZE:
+            evict_key = None
+            oldest_key = None
+            oldest_time = now
+
+            for icon_key, icon in self._cache.items():
+                # evict large icons first
+                if icon.data_size > self.CACHE_MAX_ICON_SIZE:
+                    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._cache[evict_key].data_size
+            del self._cache[evict_key]
+
+class _IconInfo(object):
+    def __init__(self):
+        self.file_name = None
+        self.attach_x = 0
+        self.attach_y = 0
+
+class _BadgeInfo(object):
+    def __init__(self):
+        self.attach_x = 0
+        self.attach_y = 0
+        self.size = 0
+        self.icon_padding = 0
+
+class _IconBuffer(object):
+    def __init__(self):
+        self._svg_loader = _get_svg_loader()
+        self._surface_cache = {}
+        self._cache_size = 1
+
+        self.icon_name = None
+        self.file_name = None
+        self.fill_color = None
+        self.stroke_color = None
+        self.badge_name = None
+        self.width = None
+        self.height = None
+
+    def _get_cache_key(self):
+        return (self.icon_name, self.file_name, self.fill_color,
+                self.stroke_color, self.badge_name, self.width, self.height)
+
+    def _load_svg(self, file_name):
+        entities = {}
+        if self.fill_color:
+            entities['fill_color'] = self.fill_color
+        if self.stroke_color:
+            entities['stroke_color'] = self.stroke_color
+
+        return self._svg_loader.load(file_name, entities)
+
+    def _get_attach_points(self, info, size_request):
+        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
+        else:
+            attach_x = attach_y = 0
+
+        return attach_x, attach_y
+
+    def _get_icon_info(self):
+        icon_info = _IconInfo()
+
+        if self.file_name:
+            icon_info.file_name = self.file_name
+        elif self.icon_name:
+            theme = gtk.icon_theme_get_default()
+
+            size = 50
+            if self.width != None:
+                size = self.width
+
+            info = theme.lookup_icon(self.icon_name, size, 0)
+            if info:
+                attach_x, attach_y = self._get_attach_points(info, size)
+
+                icon_info.file_name = info.get_filename()
+                icon_info.attach_x = attach_x
+                icon_info.attach_y = attach_y
+            else:
+                logging.warning('No icon with the name %s was found in the theme.' % self.icon_name)
+
+        return icon_info
+
+    def _draw_badge(self, context, size):
+        theme = gtk.icon_theme_get_default()
+        badge_info = theme.lookup_icon(self.badge_name, size, 0)
+        if badge_info:
+            badge_file_name = badge_info.get_filename()
+            if badge_file_name.endswith('.svg'):
+                handle = self._svg_loader.load(badge_file_name, {})
+                handle.render_cairo(context)
+            else:
+                pixbuf = gtk.gdk.pixbuf_new_from_file(badge_file_name)
+                surface = hippo.cairo_surface_from_gdk_pixbuf(pixbuf)
+                context.set_source_surface(surface, 0, 0)
+                context.paint()
+
+    def _get_size(self, icon_width, icon_height):
+        if self.width is not None and self.height is not None:
+            width = self.width
+            height = self.height
+        else:
+            width = icon_width
+            height = icon_height
+
+        return width, height
+
+    def _get_badge_info(self, icon_info, icon_width, icon_height):
+        info = _BadgeInfo()
+        if self.badge_name is None:
+            return info
+
+        info.size = int(_BADGE_SIZE * icon_width)
+        info.attach_x = int(icon_info.attach_x * icon_width - info.size / 2)
+        info.attach_y = int(icon_info.attach_y * icon_height - info.size / 2)
+
+        if info.attach_x < 0 or info.attach_y < 0:
+            info.icon_padding = max(-info.attach_x, -info.attach_y)
+        elif info.attach_x + info.size > icon_width or \
+             info.attach_y + info.size > icon_height:
+            x_padding = info.attach_x + info.size - icon_width
+            y_padding = info.attach_y + info.size - icon_height
+            info.icon_padding = max(x_padding, y_padding)
+
+        return info
+
+    def get_surface(self):
+        cache_key = self._get_cache_key()
+        if self._surface_cache.has_key(cache_key):
+            return self._surface_cache[cache_key]
+
+        icon_info = self._get_icon_info()
+        if icon_info.file_name is None:
+            return None
+
+        is_svg = icon_info.file_name.endswith('.svg')
+
+        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])
+        else:
+            pixbuf = gtk.gdk.pixbuf_new_from_file(icon_info.file_name)
+            icon_width = pixbuf.get_width()
+            icon_height = pixbuf.get_height()
+
+        badge_info = self._get_badge_info(icon_info, icon_width, icon_height)
+
+        width, height = self._get_size(icon_width, icon_height)
+        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
+
+        context = cairo.Context(surface)
+        padding = badge_info.icon_padding
+        context.scale(float(width) / (icon_width + padding * 2),
+                      float(height) / (icon_height + padding * 2))
+        context.save()
+
+        context.translate(padding, padding)
+        if is_svg:
+            handle.render_cairo(context)
+        else:
+            pixbuf_surface = hippo.cairo_surface_from_gdk_pixbuf(pixbuf)
+            context.set_source_surface(pixbuf_surface, 0, 0)
+            context.paint()
+
+        if self.badge_name:
+            context.restore()
+            context.translate(badge_info.attach_x, badge_info.attach_y)
+            self._draw_badge(context, badge_info.size)
+
+        if (len(self._surface_cache) == self._cache_size):
+            self._surface_cache.popitem()
+        self._surface_cache[cache_key] = surface
+
+        return surface
+
+    def get_cache_size(self):
+        return self._cache_size
+
+    def set_cache_size(self, cache_size):
+        while len(self._surface_cache) > cache_size:
+            self._surface_cache.popitem()
+        self._cache_size = cache_size
+
+    cache_size = property(get_cache_size, set_cache_size)
 
 class Icon(gtk.Image):
     __gtype_name__ = 'SugarIcon'
@@ -31,124 +300,219 @@ class Icon(gtk.Image):
         'fill-color'    : (object, None, None,
                            gobject.PARAM_READWRITE),
         'stroke-color'  : (object, None, None,
+                           gobject.PARAM_READWRITE),
+        'badge-name'    : (str, None, None, None,
                            gobject.PARAM_READWRITE)
     }
 
-    def __init__(self, name, **kwargs):
-        self._constructed = False
-        self._fill_color = None
-        self._stroke_color = None
-        self._icon_name = name
-        self._theme = gtk.icon_theme_get_default()
-        self._data = None
+    def __init__(self, **kwargs):
+        self._buffer = _IconBuffer()
 
         gobject.GObject.__init__(self, **kwargs)
 
-        self._constructed = True
-        self._update_icon()
+    def _sync_image_properties(self):
+        if self._buffer.icon_name != self.props.icon_name:
+            self._buffer.icon_name = self.props.icon_name
 
-    def _get_pixbuf(self, data, width, height):
-         loader = gtk.gdk.PixbufLoader('svg')
-         loader.set_size(width, height)
-         loader.write(data, len(data))
-         loader.close()
-         return loader.get_pixbuf()
+        if self._buffer.file_name != self.props.file:
+            self._buffer.file_name = self.props.file
 
-    def _read_icon_data(self, icon_name):
-        filename = self._get_real_name(icon_name)
-        icon_file = open(filename, 'r')
-        data = icon_file.read()
-        icon_file.close()
+        width, height = gtk.icon_size_lookup(self.props.icon_size)
+        if self._buffer.width != width and self._buffer.height != height:
+            self._buffer.width = width
+            self._buffer.height = height
 
-        return data
+    def _icon_size_changed_cb(self, image, pspec):
+        self._buffer.icon_size = self.props.icon_size
 
-    def _update_normal_icon(self):
-        icon_theme = gtk.icon_theme_get_for_screen(self.get_screen())
-        icon_set = gtk.IconSet()
+    def _icon_name_changed_cb(self, image, pspec):
+        self._buffer.icon_name = self.props.icon_name
 
-        if icon_theme.has_icon(self._icon_name) or os.path.exists(self._icon_name):
-            source = gtk.IconSource()
+    def _file_changed_cb(self, image, pspec):
+        self._buffer.file_name = self.props.file
 
-            if os.path.exists(self._icon_name):
-                source.set_filename(self._icon_name)
-            else:
-                source.set_icon_name(self._icon_name)
-
-            icon_set.add_source(source)
+    def _update_buffer_size(self):
+        width, height = gtk.icon_size_lookup(self.props.icon_size)
 
-        inactive_name = self._icon_name + '-inactive'
-        if icon_theme.has_icon(inactive_name) or os.path.exists(inactive_name):
-            source = gtk.IconSource()
-
-            if os.path.exists(inactive_name):
-                source.set_filename(inactive_name)
-            else:
-                source.set_icon_name(inactive_name)
+        self._buffer.width = width
+        self._buffer.height = height
 
-            source.set_state(gtk.STATE_INSENSITIVE)
-            icon_set.add_source(source)
+    def do_expose_event(self, event):
+        self._sync_image_properties()
 
-        self.props.icon_set = icon_set
+        surface = self._buffer.get_surface()
+        if surface is not None:
+            cr = self.window.cairo_create()
 
-    def _update_icon(self):
-        if not self._constructed:
-            return
+            x = self.allocation.x
+            y = self.allocation.y
 
-        if not self._fill_color and not self._stroke_color:
-            self._update_normal_icon()
-            return
-
-        if not self._data:
-            data = self._read_icon_data(self._icon_name)
-        else:
-            data = self._data
-        
-        if self._fill_color:
-            entity = '<!ENTITY fill_color "%s">' % self._fill_color
-            data = re.sub('<!ENTITY fill_color .*>', entity, data)
-
-        if self._stroke_color:
-            entity = '<!ENTITY stroke_color "%s">' % self._stroke_color
-            data = re.sub('<!ENTITY stroke_color .*>', entity, data)
-
-        self._data = data
-
-        # Redraw pixbuf
-        [w, h] = gtk.icon_size_lookup(self.props.icon_size)
-        pixbuf = self._get_pixbuf(self._data, w, h)
-        self.set_from_pixbuf(pixbuf)
-
-    def _get_real_name(self, name):
-        if os.path.exists(name):
-            return name
-
-        info = self._theme.lookup_icon(name, self.props.icon_size, 0)
-        if not info:
-            raise ValueError("Icon '" + name + "' not found.")
-        fname = info.get_filename()
-        del info
-        return fname
+            cr.set_source_surface(surface, x, y)
+            cr.paint()
 
     def do_set_property(self, pspec, value):
         if pspec.name == 'xo-color':
             self.props.fill_color = value.get_fill_color()
             self.props.stroke_color = value.get_stroke_color()
         elif pspec.name == 'fill-color':
-            self._fill_color = value
-            self._update_icon()
+            self._buffer.fill_color = value
         elif pspec.name == 'stroke-color':
-            self._stroke_color = value
-            self._update_icon()
+            self._buffer.stroke_color = value
+        elif pspec.name == 'badge-name':
+            self._buffer.badge_name = value
         else:
             gtk.Image.do_set_property(self, pspec, value)
 
-        if pspec.name == 'icon-size':
-            self._update_icon()
-
     def do_get_property(self, pspec):
         if pspec.name == 'fill-color':
-            return self._fill_color
+            return self._buffer.fill_color
         elif pspec.name == 'stroke-color':
-            return self._stroke_color
+            return self._buffer.stroke_color
+        elif pspec.name == 'badge-name':
+            return self._buffer.badge_name
         else:
             return gtk.Image.do_get_property(self, pspec)
+
+class CanvasIcon(hippo.CanvasBox, hippo.CanvasItem):
+    __gtype_name__ = 'CanvasIcon'
+
+    __gproperties__ = {
+        'file-name'     : (str, None, None, None,
+                           gobject.PARAM_READWRITE),
+        'icon-name'     : (str, None, None, None,
+                           gobject.PARAM_READWRITE),
+        'xo-color'      : (object, None, None,
+                           gobject.PARAM_WRITABLE),
+        'fill-color'    : (object, None, None,
+                           gobject.PARAM_READWRITE),
+        'stroke-color'  : (object, None, None,
+                           gobject.PARAM_READWRITE),
+        'size'          : (int, None, None, 0, 1024, 0,
+                           gobject.PARAM_READWRITE),
+        'scale'         : (float, None, None, -1024.0, 1024.0, 1.0,
+                           gobject.PARAM_READWRITE),
+        'cache-size'    : (int, None, None, 0, 1024, 0,
+                           gobject.PARAM_READWRITE),
+        'badge-name'    : (str, None, None, None,
+                           gobject.PARAM_READWRITE)
+    }
+
+    def __init__(self, **kwargs):
+        self._buffer = _IconBuffer()
+
+        hippo.CanvasBox.__init__(self, **kwargs)
+
+        self._palette = None
+
+    def do_set_property(self, pspec, value):
+        if pspec.name == 'file-name':
+            self._buffer.file_name = value
+            self.emit_paint_needed(0, 0, -1, -1)
+        elif pspec.name == 'icon-name':
+            self._buffer.icon_name = value
+            self.emit_paint_needed(0, 0, -1, -1)
+        elif pspec.name == 'xo-color':
+            self.props.fill_color = value.get_fill_color()
+            self.props.stroke_color = value.get_stroke_color()
+        elif pspec.name == 'fill-color':
+            if not isinstance(value, basestring) and value is not None:
+                raise TypeError('fill-color must be a string, not %r' % type(value))
+            self._buffer.fill_color = value
+            self.emit_paint_needed(0, 0, -1, -1)
+        elif pspec.name == 'stroke-color':
+            if not isinstance(value, basestring) and value is not None:
+                raise TypeError('stroke-color must be a string, not %r' % type(value))
+            self._buffer.stroke_color = value
+            self.emit_paint_needed(0, 0, -1, -1)
+        elif pspec.name == 'size':
+            self._buffer.width = value
+            self._buffer.height = value
+            self.emit_request_changed()
+        elif pspec.name == 'scale':
+            self._buffer.scale = value
+            self.emit_request_changed()
+        elif pspec.name == 'cache-size':
+            self._buffer.cache_size = value
+        elif pspec.name == 'badge-name':
+            self._buffer.badge_name = value
+            self.emit_paint_needed(0, 0, -1, -1)
+
+    def do_get_property(self, pspec):
+        if pspec.name == 'size':
+            return self._buffer.width
+        elif pspec.name == 'file-name':
+            return self._buffer.file_name
+        elif pspec.name == 'icon-name':
+            return self._buffer.icon_name
+        elif pspec.name == 'fill-color':
+            return self._buffer.fill_color
+        elif pspec.name == 'stroke-color':
+            return self._buffer.stroke_color
+        elif pspec.name == 'cache-size':
+            return self._buffer.cache_size
+        elif pspec.name == 'badge-name':
+            return self._buffer.badge_name
+        elif pspec.name == 'scale':
+            return self._buffer.scale
+
+    def do_paint_below_children(self, cr, damaged_box):
+        surface = self._buffer.get_surface()
+        if surface:
+            width, height = self.get_allocation()
+
+            x = (width - surface.get_width()) / 2
+            y = (height - surface.get_height()) / 2
+
+            cr.set_source_surface(surface, x, y)
+            cr.paint()
+
+    def do_get_content_width_request(self):
+        surface = self._buffer.get_surface()
+        if surface:
+            size = surface.get_width()
+        elif self._buffer.width:
+            size = self._buffer.width
+        else:
+            size = 0
+
+        return size, size
+
+    def do_get_content_height_request(self, for_width):
+        surface = self._buffer.get_surface()
+        if surface:
+            size = surface.get_height()
+        elif self._buffer.height:
+            size = self._buffer.height
+        else:
+            size = 0
+
+        return size, size
+
+    def do_button_press_event(self, event):
+        self.emit_activated()
+        return True
+
+    def get_palette(self):
+        return self._palette
+    
+    def set_palette(self, palette):
+        self._palette = palette
+        if not self._palette.props.invoker:
+            self._palette.props.invoker = CanvasInvoker(self)
+
+    def set_tooltip(self, text):
+        self.set_palette(Palette(text))
+    
+    palette = property(get_palette, set_palette)
+
+def get_icon_state(base_name, perc):
+        step = 5
+        strength = round(perc / step) * step
+        icon_theme = gtk.icon_theme_get_default()
+
+        while strength <= 100:
+            icon_name = '%s-%03d' % (base_name, strength)
+            if icon_theme.has_icon(icon_name):
+                return icon_name
+
+            strength = strength + step
diff --git a/sugar/graphics/iconbutton.py b/sugar/graphics/iconbutton.py
index ba9fad8..fd977f6 100644
--- a/sugar/graphics/iconbutton.py
+++ b/sugar/graphics/iconbutton.py
@@ -24,18 +24,18 @@ import sys
 import gobject
 import hippo
 
-from sugar.graphics.canvasicon import CanvasIcon
+from sugar.graphics.icon import CanvasIcon
 from sugar.graphics import style
             
 class IconButton(CanvasIcon, hippo.CanvasItem):
     __gtype_name__ = 'SugarIconButton'    
 
     def __init__(self, **kwargs):
-        CanvasIcon.__init__(self, cache=True, **kwargs)
+        CanvasIcon.__init__(self, **kwargs)
 
         if not self.props.fill_color and not self.props.stroke_color:
-            self.props.fill_color = style.Color("#404040")
-            self.props.stroke_color = style.Color("#FFFFFF")
+            self.props.fill_color = style.Color("#404040").get_svg()
+            self.props.stroke_color = style.Color("#FFFFFF").get_svg()
 
         self.connect('activated', self._icon_clicked_cb)
 
@@ -43,18 +43,6 @@ class IconButton(CanvasIcon, hippo.CanvasItem):
         self.props.box_height = style.GRID_CELL_SIZE
         self.props.size = style.STANDARD_ICON_SIZE
 
-    def do_button_press_event(self, event):
-        if self._active:
-            self.emit_activated()
-        return True
-
-    def prelight(self, enter):
-        if enter:
-            if self.props.active:
-                self.props.background_color = 0x000000FF
-        else:
-            self.props.background_color = 0x00000000
-
     def _icon_clicked_cb(self, button):
         if self._palette:
             self._palette.popdown(True)
diff --git a/sugar/graphics/menuitem.py b/sugar/graphics/menuitem.py
index db4a293..5b457a5 100644
--- a/sugar/graphics/menuitem.py
+++ b/sugar/graphics/menuitem.py
@@ -22,7 +22,7 @@ class MenuItem(gtk.ImageMenuItem):
     def __init__(self, text_label, icon_name=None):
         gtk.ImageMenuItem.__init__(self, text_label)
         if icon_name:
-            icon = Icon(icon_name, icon_size=gtk.ICON_SIZE_MENU)
+            icon = Icon(icon_name=icon_name, icon_size=gtk.ICON_SIZE_MENU)
             self.set_image(icon)
             icon.show()
 
diff --git a/sugar/graphics/objectchooser.py b/sugar/graphics/objectchooser.py
index f929063..4128cf3 100644
--- a/sugar/graphics/objectchooser.py
+++ b/sugar/graphics/objectchooser.py
@@ -24,9 +24,9 @@ import hippo
 from sugar.activity.bundle import Bundle
 from sugar.date import Date
 from sugar.graphics import style
-from sugar.graphics.canvasicon import CanvasIcon
+from sugar.graphics.icon import CanvasIcon
 from sugar.graphics.xocolor import XoColor
-from sugar.graphics.canvasroundbox import CanvasRoundBox
+from sugar.graphics.roundbox import CanvasRoundBox
 from sugar.datastore import datastore
 from sugar import activity
 from sugar.objects import objecttype
@@ -150,7 +150,7 @@ class CollapsedEntry(CanvasRoundBox):
                 self._icon_name = type.icon
 
         if not self._icon_name:
-            self._icon_name = 'theme:image-missing'
+            self._icon_name = 'image-missing'
 
         return self._icon_name
 
diff --git a/sugar/graphics/radiotoolbutton.py b/sugar/graphics/radiotoolbutton.py
index cf0cc64..a8269dd 100644
--- a/sugar/graphics/radiotoolbutton.py
+++ b/sugar/graphics/radiotoolbutton.py
@@ -31,7 +31,7 @@ class RadioToolButton(gtk.RadioToolButton):
         self.set_named_icon(named_icon)
 
     def set_named_icon(self, named_icon):
-        icon = Icon(named_icon,
+        icon = Icon(icon_name=named_icon,
                     xo_color=self._xo_color,
                     icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR)
         self.set_icon_widget(icon)
diff --git a/sugar/graphics/canvasroundbox.py b/sugar/graphics/roundbox.py
index 51b9e7d..51b9e7d 100644
--- a/sugar/graphics/canvasroundbox.py
+++ b/sugar/graphics/roundbox.py
diff --git a/sugar/graphics/toggletoolbutton.py b/sugar/graphics/toggletoolbutton.py
index a83bebc..4fbfa66 100644
--- a/sugar/graphics/toggletoolbutton.py
+++ b/sugar/graphics/toggletoolbutton.py
@@ -29,7 +29,7 @@ class ToggleToolButton(gtk.ToggleToolButton):
         self.set_named_icon(named_icon)
 
     def set_named_icon(self, named_icon):
-        icon = Icon(named_icon)
+        icon = Icon(icon_name=named_icon)
         self.set_icon_widget(icon)
         icon.show()
 
diff --git a/sugar/graphics/toolbutton.py b/sugar/graphics/toolbutton.py
index 2b90fd4..4db7d90 100644
--- a/sugar/graphics/toolbutton.py
+++ b/sugar/graphics/toolbutton.py
@@ -33,7 +33,7 @@ class ToolButton(gtk.ToolButton):
         self.connect('clicked', self._button_clicked_cb)
 
     def set_icon(self, icon_name):
-        icon = Icon(icon_name)
+        icon = Icon(icon_name=icon_name)
         self.set_icon_widget(icon)
         icon.show()
 
diff --git a/sugar/graphics/tray.py b/sugar/graphics/tray.py
new file mode 100644
index 0000000..bfc4ad1
--- /dev/null
+++ b/sugar/graphics/tray.py
@@ -0,0 +1,89 @@
+# Copyright (C) 2007, One Laptop Per Child
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2 of the License, or (at your option) any later version.
+#
+# This library 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
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the
+# Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+# Boston, MA 02111-1307, USA.
+
+import gobject
+import gtk
+
+from sugar.graphics.toolbutton import ToolButton
+from sugar.graphics.icon import Icon
+
+class _TrayViewport(gtk.Viewport):
+    def __init__(self):
+        gobject.GObject.__init__(self)
+
+        self.set_shadow_type(gtk.SHADOW_NONE)
+
+        self.traybar = gtk.Toolbar()
+        self.traybar.set_show_arrow(False)
+        self.add(self.traybar)
+        self.traybar.show()
+
+    def scroll_right(self):
+        adj = self.get_hadjustment()
+        new_value = adj.value + self.allocation.width
+        adj.value = min(new_value, adj.upper - self.allocation.width)
+
+    def scroll_left(self):
+        adj = self.get_hadjustment()
+        new_value = adj.value - self.allocation.width
+        adj.value = max(adj.lower, new_value)
+
+class HTray(gtk.HBox):
+    def __init__(self, **kwargs):
+        gobject.GObject.__init__(self, **kwargs)
+
+        self._scroll_left = gtk.Button()
+        self._scroll_left.set_relief(gtk.RELIEF_NONE)
+        self._scroll_left.connect('clicked', self._scroll_left_cb)
+
+        icon = Icon(icon_name='go-left', icon_size=gtk.ICON_SIZE_MENU)
+        self._scroll_left.set_image(icon)
+        icon.show()
+
+        self.pack_start(self._scroll_left, False)
+        self._scroll_left.show()
+
+        self._viewport = _TrayViewport()
+        self.pack_start(self._viewport)
+        self._viewport.show()
+
+        self._scroll_right = gtk.Button()
+        self._scroll_right.set_relief(gtk.RELIEF_NONE)
+        self._scroll_right.connect('clicked', self._scroll_right_cb)
+
+        icon = Icon(icon_name='go-right', icon_size=gtk.ICON_SIZE_MENU)
+        self._scroll_right.set_image(icon)
+        icon.show()
+
+        self.pack_start(self._scroll_right, False)
+        self._scroll_right.show()
+
+    def _scroll_left_cb(self, button):
+        self._viewport.scroll_left()
+
+    def _scroll_right_cb(self, button):
+        self._viewport.scroll_right()
+
+    def add_item(self, item, index=-1):
+        self._viewport.traybar.insert(item, index)
+
+    def remove_item(self, index):
+        self._viewport.traybar.remove(item)
+
+class TrayButton(ToolButton):
+    def __init__(self, **kwargs):
+        ToolButton.__init__(self, **kwargs)
diff --git a/sugar/presence/activity.py b/sugar/presence/activity.py
index 2df8793..bdfc74f 100644
--- a/sugar/presence/activity.py
+++ b/sugar/presence/activity.py
@@ -167,16 +167,17 @@ class Activity(gobject.GObject):
         return bus_name, connection, channels
 
     def _leave_cb(self):
-        # XXX Is this the right thing to do?
+        """Callback for async action of leaving shared activity."""
         self.emit("joined", False, "left activity")
 
     def _leave_error_cb(self, err):
-        # XXX We are closing down anyway
+        """Callback for error in async leaving of shared activity.
+
+        XXX Add logging!"""
         pass
 
     def leave(self):
         """Leave this shared activity"""
-        # FIXME
         self._joined = False
         self._activity.Leave(reply_handler=self._leave_cb,
                              error_handler=self._leave_error_cb)
diff --git a/sugar/presence/presenceservice.py b/sugar/presence/presenceservice.py
index 7b64b20..c8e23db 100644
--- a/sugar/presence/presenceservice.py
+++ b/sugar/presence/presenceservice.py
@@ -421,7 +421,11 @@ class PresenceService(gobject.GObject):
         return self._new_object(owner_op)
 
     def _share_activity_cb(self, activity, op):
-        """Notify with GObject event of successful sharing of activity"""
+        """Notify with GObject event of successful sharing of activity
+        
+        op -- full dbus path of the new object, must be
+            prefixed with either of _PS_BUDDY_OP or _PS_ACTIVITY_OP
+        """
         psact = self._new_object(op)
         psact._joined = True
         self.emit("activity-shared", True, psact, None)
@@ -431,10 +435,10 @@ class PresenceService(gobject.GObject):
         _logger.debug("Error sharing activity %s: %s" % (activity.get_id(), err))
         self.emit("activity-shared", False, None, err)
 
-    def share_activity(self, activity, properties={}):
-        """Ask presence service to ask the activity to share itself
+    def share_activity(self, activity, properties={}, private=True):
+        """Ask presence service to ask the activity to share itself publicly.
         
-        Uses the ShareActivity method on the service to ask for the 
+        Uses the AdvertiseActivity method on the service to ask for the 
         sharing of the given activity.  Arranges to emit activity-shared 
         event with:
         
@@ -445,19 +449,33 @@ class PresenceService(gobject.GObject):
         returns None
         """
         actid = activity.get_id()
+        _logger.debug('XXXX in share_activity')
 
         # Ensure the activity is not already shared/joined
         for obj in self._objcache.values():
             if not isinstance(object, Activity):
                 continue
             if obj.props.id == actid or obj.props.joined:
-                raise RuntimeError("Activity %s is already shared." % actid)
+                raise RuntimeError("Activity %s is already shared." %
+                                   actid)
 
         atype = activity.get_service_name()
         name = activity.props.title
-        self._ps.ShareActivity(actid, atype, name, properties,
-                reply_handler=lambda *args: self._share_activity_cb(activity, *args),
-                error_handler=lambda *args: self._share_activity_error_cb(activity, *args))
+        if private:
+            _logger.debug('XXXX private, so calling InviteActivity')
+            self._ps.InviteActivity(actid, atype, name, properties,
+                    reply_handler=lambda *args: \
+                        self._share_activity_cb(activity, *args),
+                    error_handler=lambda *args: \
+                        self._share_activity_error_cb(activity, *args))
+        else:
+            # FIXME: Test, then make this AdvertiseActivity:
+            _logger.debug('XXXX not private, so calling ShareActivity')
+            self._ps.ShareActivity(actid, atype, name, properties,
+                    reply_handler=lambda *args: \
+                        self._share_activity_cb(activity, *args),
+                    error_handler=lambda *args: \
+                        self._share_activity_error_cb(activity, *args))
 
     def get_preferred_connection(self):
         """Gets the preferred telepathy connection object that an activity