Changed all tabs to 4 spaces for python style

4 files changed, 555 insertions, 555 deletions

diff --git a/sugar/presence/Activity.py b/sugar/presence/Activity.py
index e267d83..06c8a00 100644
--- a/sugar/presence/Activity.py
+++ b/sugar/presence/Activity.py
@@ -20,98 +20,98 @@ import dbus
 
 class Activity(gobject.GObject):
 
-	__gsignals__ = {
-		'buddy-joined': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([gobject.TYPE_PYOBJECT])),
-		'buddy-left': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([gobject.TYPE_PYOBJECT])),
-		'service-appeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([gobject.TYPE_PYOBJECT])),
-		'service-disappeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([gobject.TYPE_PYOBJECT]))
-	}
-
-	_PRESENCE_SERVICE = "org.laptop.Presence"
-	_ACTIVITY_DBUS_INTERFACE = "org.laptop.Presence.Activity"
-
-	def __init__(self, bus, new_obj_cb, del_obj_cb, object_path):
-		gobject.GObject.__init__(self)
-		self._object_path = object_path
-		self._ps_new_object = new_obj_cb
-		self._ps_del_object = del_obj_cb
-		bobj = bus.get_object(self._PRESENCE_SERVICE, object_path)
-		self._activity = dbus.Interface(bobj, self._ACTIVITY_DBUS_INTERFACE)
-		self._activity.connect_to_signal('BuddyJoined', self._buddy_joined_cb)
-		self._activity.connect_to_signal('BuddyLeft', self._buddy_left_cb)
-		self._activity.connect_to_signal('ServiceAppeared', self._service_appeared_cb)
-		self._activity.connect_to_signal('ServiceDisappeared', self._service_disappeared_cb)
-		
-		self._id = None
-		self._color = None
-
-	def object_path(self):
-		return self._object_path
-
-	def _emit_buddy_joined_signal(self, object_path):
-		self.emit('buddy-joined', self._ps_new_object(object_path))
-		return False
-
-	def _buddy_joined_cb(self, object_path):
-		gobject.idle_add(self._emit_buddy_joined_signal, object_path)
-
-	def _emit_buddy_left_signal(self, object_path):
-		self.emit('buddy-left', self._ps_new_object(object_path))
-		return False
-
-	def _buddy_left_cb(self, object_path):
-		gobject.idle_add(self._emit_buddy_left_signal, object_path)
-
-	def _emit_service_appeared_signal(self, object_path):
-		self.emit('service-appeared', self._ps_new_object(object_path))
-		return False
-
-	def _service_appeared_cb(self, object_path):
-		gobject.idle_add(self._emit_service_appeared_signal, object_path)
-
-	def _emit_service_disappeared_signal(self, object_path):
-		self.emit('service-disappeared', self._ps_new_object(object_path))
-		return False
-
-	def _service_disappeared_cb(self, object_path):
-		gobject.idle_add(self._emit_service_disappeared_signal, object_path)
-
-	def get_id(self):
-		# Cache activity ID, which should never change anyway
-		if not self._id:
-			self._id = self._activity.getId()
-		return self._id
-
-	def get_color(self):
-		if not self._color:
-			self._color = self._activity.getColor()
-		return self._color
-
-	def get_services(self):
-		resp = self._activity.getServices()
-		servs = []
-		for item in resp:
-			servs.append(self._ps_new_object(item))
-		return servs
-
-	def get_services_of_type(self, stype):
-		resp = self._activity.getServicesOfType(stype)
-		servs = []
-		for item in resp:
-			servs.append(self._ps_new_object(item))
-		return servs
-
-	def get_joined_buddies(self):
-		resp = self._activity.getJoinedBuddies()
-		buddies = []
-		for item in resp:
-			buddies.append(self._ps_new_object(item))
-		return buddies
-
-	def owner_has_joined(self):
-		# FIXME
-		return False
+    __gsignals__ = {
+        'buddy-joined': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([gobject.TYPE_PYOBJECT])),
+        'buddy-left': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([gobject.TYPE_PYOBJECT])),
+        'service-appeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([gobject.TYPE_PYOBJECT])),
+        'service-disappeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([gobject.TYPE_PYOBJECT]))
+    }
+
+    _PRESENCE_SERVICE = "org.laptop.Presence"
+    _ACTIVITY_DBUS_INTERFACE = "org.laptop.Presence.Activity"
+
+    def __init__(self, bus, new_obj_cb, del_obj_cb, object_path):
+        gobject.GObject.__init__(self)
+        self._object_path = object_path
+        self._ps_new_object = new_obj_cb
+        self._ps_del_object = del_obj_cb
+        bobj = bus.get_object(self._PRESENCE_SERVICE, object_path)
+        self._activity = dbus.Interface(bobj, self._ACTIVITY_DBUS_INTERFACE)
+        self._activity.connect_to_signal('BuddyJoined', self._buddy_joined_cb)
+        self._activity.connect_to_signal('BuddyLeft', self._buddy_left_cb)
+        self._activity.connect_to_signal('ServiceAppeared', self._service_appeared_cb)
+        self._activity.connect_to_signal('ServiceDisappeared', self._service_disappeared_cb)
+        
+        self._id = None
+        self._color = None
+
+    def object_path(self):
+        return self._object_path
+
+    def _emit_buddy_joined_signal(self, object_path):
+        self.emit('buddy-joined', self._ps_new_object(object_path))
+        return False
+
+    def _buddy_joined_cb(self, object_path):
+        gobject.idle_add(self._emit_buddy_joined_signal, object_path)
+
+    def _emit_buddy_left_signal(self, object_path):
+        self.emit('buddy-left', self._ps_new_object(object_path))
+        return False
+
+    def _buddy_left_cb(self, object_path):
+        gobject.idle_add(self._emit_buddy_left_signal, object_path)
+
+    def _emit_service_appeared_signal(self, object_path):
+        self.emit('service-appeared', self._ps_new_object(object_path))
+        return False
+
+    def _service_appeared_cb(self, object_path):
+        gobject.idle_add(self._emit_service_appeared_signal, object_path)
+
+    def _emit_service_disappeared_signal(self, object_path):
+        self.emit('service-disappeared', self._ps_new_object(object_path))
+        return False
+
+    def _service_disappeared_cb(self, object_path):
+        gobject.idle_add(self._emit_service_disappeared_signal, object_path)
+
+    def get_id(self):
+        # Cache activity ID, which should never change anyway
+        if not self._id:
+            self._id = self._activity.getId()
+        return self._id
+
+    def get_color(self):
+        if not self._color:
+            self._color = self._activity.getColor()
+        return self._color
+
+    def get_services(self):
+        resp = self._activity.getServices()
+        servs = []
+        for item in resp:
+            servs.append(self._ps_new_object(item))
+        return servs
+
+    def get_services_of_type(self, stype):
+        resp = self._activity.getServicesOfType(stype)
+        servs = []
+        for item in resp:
+            servs.append(self._ps_new_object(item))
+        return servs
+
+    def get_joined_buddies(self):
+        resp = self._activity.getJoinedBuddies()
+        buddies = []
+        for item in resp:
+            buddies.append(self._ps_new_object(item))
+        return buddies
+
+    def owner_has_joined(self):
+        # FIXME
+        return False
diff --git a/sugar/presence/Buddy.py b/sugar/presence/Buddy.py
index 579592b..740b29b 100644
--- a/sugar/presence/Buddy.py
+++ b/sugar/presence/Buddy.py
@@ -21,173 +21,173 @@ import dbus
 
 class Buddy(gobject.GObject):
 
-	__gsignals__ = {
-		'icon-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([])),
-		'disappeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([])),
-		'service-appeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([gobject.TYPE_PYOBJECT])),
-		'service-disappeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([gobject.TYPE_PYOBJECT])),
-		'joined-activity': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([gobject.TYPE_PYOBJECT])),
-		'left-activity': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([gobject.TYPE_PYOBJECT])),
-		'property-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([gobject.TYPE_PYOBJECT])),
-		'current-activity-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([gobject.TYPE_PYOBJECT]))
-	}
-
-	_PRESENCE_SERVICE = "org.laptop.Presence"
-	_BUDDY_DBUS_INTERFACE = "org.laptop.Presence.Buddy"
-
-	def __init__(self, bus, new_obj_cb, del_obj_cb, object_path):
-		gobject.GObject.__init__(self)
-		self._object_path = object_path
-		self._ps_new_object = new_obj_cb
-		self._ps_del_object = del_obj_cb
-		self._properties = {}
-		bobj = bus.get_object(self._PRESENCE_SERVICE, object_path)
-		self._buddy = dbus.Interface(bobj, self._BUDDY_DBUS_INTERFACE)
-		self._buddy.connect_to_signal('IconChanged', self._icon_changed_cb)
-		self._buddy.connect_to_signal('ServiceAppeared', self._service_appeared_cb)
-		self._buddy.connect_to_signal('ServiceDisappeared', self._service_disappeared_cb)
-		self._buddy.connect_to_signal('Disappeared', self._disappeared_cb)
-		self._buddy.connect_to_signal('JoinedActivity', self._joined_activity_cb)
-		self._buddy.connect_to_signal('LeftActivity', self._left_activity_cb)
-		self._buddy.connect_to_signal('PropertyChanged', self._property_changed_cb)
-		self._buddy.connect_to_signal('CurrentActivityChanged', self._current_activity_changed_cb)
-		self._properties = self._get_properties_helper()
-
-		self._current_activity = None
-		try:
-			self._current_activity = self._buddy.getCurrentActivity()
-		except Exception, e:
-			pass
-
-	def _get_properties_helper(self):
-		props = self._buddy.getProperties()
-		if not props:
-			return {}
-		return props
-
-	def object_path(self):
-		return self._object_path
-
-	def _emit_icon_changed_signal(self):
-		self.emit('icon-changed')
-		return False
-
-	def _icon_changed_cb(self):
-		gobject.idle_add(self._emit_icon_changed_signal)
-
-	def _emit_disappeared_signal(self):
-		self.emit('disappeared')
-
-	def _disappeared_cb(self):
-		gobject.idle_add(self._emit_disappeared_signal)
-
-	def _emit_service_appeared_signal(self, object_path):
-		self.emit('service-appeared', self._ps_new_object(object_path))
-		return False
-
-	def _service_appeared_cb(self, object_path):
-		gobject.idle_add(self._emit_service_appeared_signal, object_path)
-
-	def _emit_service_disappeared_signal(self, object_path):
-		self.emit('service-disappeared', self._ps_new_object(object_path))
-		return False
-
-	def _service_disappeared_cb(self, object_path):
-		gobject.idle_add(self._emit_service_disappeared_signal, object_path)
-
-	def _emit_joined_activity_signal(self, object_path):
-		self.emit('joined-activity', self._ps_new_object(object_path))
-		return False
-
-	def _joined_activity_cb(self, object_path):
-		gobject.idle_add(self._emit_joined_activity_signal, object_path)
-
-	def _emit_left_activity_signal(self, object_path):
-		self.emit('left-activity', self._ps_new_object(object_path))
-		return False
-
-	def _left_activity_cb(self, object_path):
-		gobject.idle_add(self._emit_left_activity_signal, object_path)
-
-	def _handle_property_changed_signal(self, prop_list):
-		self._properties = self._get_properties_helper()
-		self.emit('property-changed', prop_list)
-		return False
-
-	def _property_changed_cb(self, prop_list):
-		gobject.idle_add(self._handle_property_changed_signal, prop_list)
-
-	def _handle_current_activity_changed_signal(self, act_list):
-		if len(act_list) == 0:
-			self._current_activity = None
-			self.emit('current-activity-changed', None)
-		else:
-			self._current_activity = act_list[0]
-			self.emit('current-activity-changed', self._ps_new_object(act_list[0]))
-		return False
-
-	def _current_activity_changed_cb(self, act_list):
-		gobject.idle_add(self._handle_current_activity_changed_signal, act_list)
-
-	def get_name(self):
-		return self._properties['name']
-
-	def get_ip4_address(self):
-		return self._properties['ip4_address']
-
-	def is_owner(self):
-		return self._properties['owner']
-
-	def get_color(self):
-		return self._properties['color']
-
-	def get_icon(self):
-		return self._buddy.getIcon()
-
-	def get_current_activity(self):
-		if not self._current_activity:
-			return None
-		return self._ps_new_object(self._current_activity)
-
-	def get_icon_pixbuf(self):
-		icon = self._buddy.getIcon()
-		if icon and len(icon):
-			pbl = gtk.gdk.PixbufLoader()
-			icon_data = ""
-			for item in icon:
-				if item < 0:
-					item = item + 128
-				icon_data = icon_data + chr(item)
-			pbl.write(icon_data)
-			pbl.close()
-			return pbl.get_pixbuf()
-		else:
-			return None
-
-	def get_service_of_type(self, stype, activity=None):
-		try:
-			act_op = "/"
-			if activity:
-				act_op = activity.object_path()
-			object_path = self._buddy.getServiceOfType(stype, act_op)
-		except dbus.exceptions.DBusException:
-			return None
-		return self._ps_new_object(object_path)
-
-	def get_joined_activities(self):
-		try:
-			resp = self._buddy.getJoinedActivities()
-		except dbus.exceptions.DBusException:
-			return []
-		acts = []
-		for item in resp:
-			acts.append(self._ps_new_object(item))
-		return acts
+    __gsignals__ = {
+        'icon-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([])),
+        'disappeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([])),
+        'service-appeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([gobject.TYPE_PYOBJECT])),
+        'service-disappeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([gobject.TYPE_PYOBJECT])),
+        'joined-activity': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([gobject.TYPE_PYOBJECT])),
+        'left-activity': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([gobject.TYPE_PYOBJECT])),
+        'property-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([gobject.TYPE_PYOBJECT])),
+        'current-activity-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([gobject.TYPE_PYOBJECT]))
+    }
+
+    _PRESENCE_SERVICE = "org.laptop.Presence"
+    _BUDDY_DBUS_INTERFACE = "org.laptop.Presence.Buddy"
+
+    def __init__(self, bus, new_obj_cb, del_obj_cb, object_path):
+        gobject.GObject.__init__(self)
+        self._object_path = object_path
+        self._ps_new_object = new_obj_cb
+        self._ps_del_object = del_obj_cb
+        self._properties = {}
+        bobj = bus.get_object(self._PRESENCE_SERVICE, object_path)
+        self._buddy = dbus.Interface(bobj, self._BUDDY_DBUS_INTERFACE)
+        self._buddy.connect_to_signal('IconChanged', self._icon_changed_cb)
+        self._buddy.connect_to_signal('ServiceAppeared', self._service_appeared_cb)
+        self._buddy.connect_to_signal('ServiceDisappeared', self._service_disappeared_cb)
+        self._buddy.connect_to_signal('Disappeared', self._disappeared_cb)
+        self._buddy.connect_to_signal('JoinedActivity', self._joined_activity_cb)
+        self._buddy.connect_to_signal('LeftActivity', self._left_activity_cb)
+        self._buddy.connect_to_signal('PropertyChanged', self._property_changed_cb)
+        self._buddy.connect_to_signal('CurrentActivityChanged', self._current_activity_changed_cb)
+        self._properties = self._get_properties_helper()
+
+        self._current_activity = None
+        try:
+            self._current_activity = self._buddy.getCurrentActivity()
+        except Exception, e:
+            pass
+
+    def _get_properties_helper(self):
+        props = self._buddy.getProperties()
+        if not props:
+            return {}
+        return props
+
+    def object_path(self):
+        return self._object_path
+
+    def _emit_icon_changed_signal(self):
+        self.emit('icon-changed')
+        return False
+
+    def _icon_changed_cb(self):
+        gobject.idle_add(self._emit_icon_changed_signal)
+
+    def _emit_disappeared_signal(self):
+        self.emit('disappeared')
+
+    def _disappeared_cb(self):
+        gobject.idle_add(self._emit_disappeared_signal)
+
+    def _emit_service_appeared_signal(self, object_path):
+        self.emit('service-appeared', self._ps_new_object(object_path))
+        return False
+
+    def _service_appeared_cb(self, object_path):
+        gobject.idle_add(self._emit_service_appeared_signal, object_path)
+
+    def _emit_service_disappeared_signal(self, object_path):
+        self.emit('service-disappeared', self._ps_new_object(object_path))
+        return False
+
+    def _service_disappeared_cb(self, object_path):
+        gobject.idle_add(self._emit_service_disappeared_signal, object_path)
+
+    def _emit_joined_activity_signal(self, object_path):
+        self.emit('joined-activity', self._ps_new_object(object_path))
+        return False
+
+    def _joined_activity_cb(self, object_path):
+        gobject.idle_add(self._emit_joined_activity_signal, object_path)
+
+    def _emit_left_activity_signal(self, object_path):
+        self.emit('left-activity', self._ps_new_object(object_path))
+        return False
+
+    def _left_activity_cb(self, object_path):
+        gobject.idle_add(self._emit_left_activity_signal, object_path)
+
+    def _handle_property_changed_signal(self, prop_list):
+        self._properties = self._get_properties_helper()
+        self.emit('property-changed', prop_list)
+        return False
+
+    def _property_changed_cb(self, prop_list):
+        gobject.idle_add(self._handle_property_changed_signal, prop_list)
+
+    def _handle_current_activity_changed_signal(self, act_list):
+        if len(act_list) == 0:
+            self._current_activity = None
+            self.emit('current-activity-changed', None)
+        else:
+            self._current_activity = act_list[0]
+            self.emit('current-activity-changed', self._ps_new_object(act_list[0]))
+        return False
+
+    def _current_activity_changed_cb(self, act_list):
+        gobject.idle_add(self._handle_current_activity_changed_signal, act_list)
+
+    def get_name(self):
+        return self._properties['name']
+
+    def get_ip4_address(self):
+        return self._properties['ip4_address']
+
+    def is_owner(self):
+        return self._properties['owner']
+
+    def get_color(self):
+        return self._properties['color']
+
+    def get_icon(self):
+        return self._buddy.getIcon()
+
+    def get_current_activity(self):
+        if not self._current_activity:
+            return None
+        return self._ps_new_object(self._current_activity)
+
+    def get_icon_pixbuf(self):
+        icon = self._buddy.getIcon()
+        if icon and len(icon):
+            pbl = gtk.gdk.PixbufLoader()
+            icon_data = ""
+            for item in icon:
+                if item < 0:
+                    item = item + 128
+                icon_data = icon_data + chr(item)
+            pbl.write(icon_data)
+            pbl.close()
+            return pbl.get_pixbuf()
+        else:
+            return None
+
+    def get_service_of_type(self, stype, activity=None):
+        try:
+            act_op = "/"
+            if activity:
+                act_op = activity.object_path()
+            object_path = self._buddy.getServiceOfType(stype, act_op)
+        except dbus.exceptions.DBusException:
+            return None
+        return self._ps_new_object(object_path)
+
+    def get_joined_activities(self):
+        try:
+            resp = self._buddy.getJoinedActivities()
+        except dbus.exceptions.DBusException:
+            return []
+        acts = []
+        for item in resp:
+            acts.append(self._ps_new_object(item))
+        return acts
diff --git a/sugar/presence/PresenceService.py b/sugar/presence/PresenceService.py
index d74b0c5..fd6091e 100644
--- a/sugar/presence/PresenceService.py
+++ b/sugar/presence/PresenceService.py
@@ -20,23 +20,23 @@ import dbus, dbus.glib, gobject
 import Buddy, Service, Activity
 
 class ObjectCache(object):
-	def __init__(self):
-		self._cache = {}
+    def __init__(self):
+        self._cache = {}
 
-	def get(self, object_path):
-		try:
-			return self._cache[object_path]
-		except KeyError:
-			return None
+    def get(self, object_path):
+        try:
+            return self._cache[object_path]
+        except KeyError:
+            return None
 
-	def add(self, obj):
-		op = obj.object_path()
-		if not self._cache.has_key(op):
-			self._cache[op] = obj
+    def add(self, obj):
+        op = obj.object_path()
+        if not self._cache.has_key(op):
+            self._cache[op] = obj
 
-	def remove(self, object_path):
-		if self._cache.has_key(object_path):
-			del self._cache[object_path]
+    def remove(self, object_path):
+        if self._cache.has_key(object_path):
+            del self._cache[object_path]
 
 
 DBUS_SERVICE = "org.laptop.Presence"
@@ -46,192 +46,192 @@ DBUS_PATH = "/org/laptop/Presence"
 
 class PresenceService(gobject.GObject):
 
-	__gsignals__ = {
-		'buddy-appeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						([gobject.TYPE_PYOBJECT])),
-		'buddy-disappeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						([gobject.TYPE_PYOBJECT])),
-		'service-appeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						([gobject.TYPE_PYOBJECT])),
-		'service-disappeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						([gobject.TYPE_PYOBJECT])),
-		'activity-appeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						([gobject.TYPE_PYOBJECT])),
-		'activity-disappeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						([gobject.TYPE_PYOBJECT]))
-	}
-
-	_PS_BUDDY_OP = DBUS_PATH + "/Buddies/"
-	_PS_SERVICE_OP = DBUS_PATH + "/Services/"
-	_PS_ACTIVITY_OP = DBUS_PATH + "/Activities/"
-	
-
-	def __init__(self):
-		gobject.GObject.__init__(self)
-		self._objcache = ObjectCache()
-		self._bus = dbus.SessionBus()
-		self._ps = dbus.Interface(self._bus.get_object(DBUS_SERVICE,
-				DBUS_PATH), DBUS_INTERFACE)
-		self._ps.connect_to_signal('BuddyAppeared', self._buddy_appeared_cb)
-		self._ps.connect_to_signal('BuddyDisappeared', self._buddy_disappeared_cb)
-		self._ps.connect_to_signal('ServiceAppeared', self._service_appeared_cb)
-		self._ps.connect_to_signal('ServiceDisappeared', self._service_disappeared_cb)
-		self._ps.connect_to_signal('ActivityAppeared', self._activity_appeared_cb)
-		self._ps.connect_to_signal('ActivityDisappeared', self._activity_disappeared_cb)
-
-	def _new_object(self, object_path):
-		obj = self._objcache.get(object_path)
-		if not obj:
-			if object_path.startswith(self._PS_SERVICE_OP):
-				obj = Service.Service(self._bus, self._new_object,
-						self._del_object, object_path)
-			elif object_path.startswith(self._PS_BUDDY_OP):
-				obj = Buddy.Buddy(self._bus, self._new_object,
-						self._del_object, object_path)
-			elif object_path.startswith(self._PS_ACTIVITY_OP):
-				obj = Activity.Activity(self._bus, self._new_object,
-						self._del_object, object_path)
-			else:
-				raise RuntimeError("Unknown object type")
-			self._objcache.add(obj)
-		return obj
-
-	def _del_object(self, object_path):
-		# FIXME
-		pass
-
-	def _emit_buddy_appeared_signal(self, object_path):
-		self.emit('buddy-appeared', self._new_object(object_path))
-		return False
-
-	def _buddy_appeared_cb(self, op):
-		gobject.idle_add(self._emit_buddy_appeared_signal, op)
-
-	def _emit_buddy_disappeared_signal(self, object_path):
-		self.emit('buddy-disappeared', self._new_object(object_path))
-		return False
-
-	def _buddy_disappeared_cb(self, object_path):
-		gobject.idle_add(self._emit_buddy_disappeared_signal, object_path)
-
-	def _emit_service_appeared_signal(self, object_path):
-		self.emit('service-appeared', self._new_object(object_path))
-		return False
-
-	def _service_appeared_cb(self, object_path):
-		gobject.idle_add(self._emit_service_appeared_signal, object_path)
-
-	def _emit_service_disappeared_signal(self, object_path):
-		self.emit('service-disappeared', self._new_object(object_path))
-		return False
-
-	def _service_disappeared_cb(self, object_path):
-		gobject.idle_add(self._emit_service_disappeared_signal, object_path)
-
-	def _emit_activity_appeared_signal(self, object_path):
-		self.emit('activity-appeared', self._new_object(object_path))
-		return False
-
-	def _activity_appeared_cb(self, object_path):
-		gobject.idle_add(self._emit_activity_appeared_signal, object_path)
-
-	def _emit_activity_disappeared_signal(self, object_path):
-		self.emit('activity-disappeared', self._new_object(object_path))
-		return False
-
-	def _activity_disappeared_cb(self, object_path):
-		gobject.idle_add(self._emit_activity_disappeared_signal, object_path)
-
-	def get(self, object_path):
-		return self._new_object(object_path)
-
-	def get_services(self):
-		resp = self._ps.getServices()
-		servs = []
-		for item in resp:
-			servs.append(self._new_object(item))
-		return servs
-
-	def get_services_of_type(self, stype):
-		resp = self._ps.getServicesOfType(stype)
-		servs = []
-		for item in resp:
-			servs.append(self._new_object(item))
-		return servs
-
-	def get_activities(self):
-		resp = self._ps.getActivities()
-		acts = []
-		for item in resp:
-			acts.append(self._new_object(item))
-		return acts
-
-	def get_activity(self, activity_id):
-		try:
-			act_op = self._ps.getActivity(activity_id)
-		except dbus.exceptions.DBusException:
-			return None
-		return self._new_object(act_op)
-
-	def get_buddies(self):
-		resp = self._ps.getBuddies()
-		buddies = []
-		for item in resp:
-			buddies.append(self._new_object(item))
-		return buddies
-
-	def get_buddy_by_name(self, name):
-		try:
-			buddy_op = self._ps.getBuddyByName(name)
-		except dbus.exceptions.DBusException:
-			return None
-		return self._new_object(buddy_op)
-
-	def get_buddy_by_address(self, addr):
-		try:
-			buddy_op = self._ps.getBuddyByAddress(addr)
-		except dbus.exceptions.DBusException:
-			return None
-		return self._new_object(buddy_op)
-
-	def get_owner(self):
-		try:
-			owner_op = self._ps.getOwner()
-		except dbus.exceptions.DBusException:
-			return None
-		return self._new_object(owner_op)
-
-	def share_activity(self, activity, stype, properties={}, address=None, port=-1, domain=u"local"):
-		actid = activity.get_id()
-		if address == None:
-			address = u""
-		serv_op = self._ps.shareActivity(actid, stype, properties, address, port, domain)
-		return self._new_object(serv_op)
-
-	def register_service(self, name, stype, properties={}, address=None, port=-1, domain=u"local"):
-		if address == None:
-			address = u""
-		serv_op = self._ps.registerService(name, stype, properties, address, port, domain)
-		return self._new_object(serv_op)
-
-	def unregister_service(self, service):
-		self._ps.unregisterService(service.object_path())
-
-	def register_service_type(self, stype):
-		self._ps.registerServiceType(stype)
-
-	def unregister_service_type(self, stype):
-		self._ps.unregisterServiceType(stype)
+    __gsignals__ = {
+        'buddy-appeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                        ([gobject.TYPE_PYOBJECT])),
+        'buddy-disappeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                        ([gobject.TYPE_PYOBJECT])),
+        'service-appeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                        ([gobject.TYPE_PYOBJECT])),
+        'service-disappeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                        ([gobject.TYPE_PYOBJECT])),
+        'activity-appeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                        ([gobject.TYPE_PYOBJECT])),
+        'activity-disappeared': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                        ([gobject.TYPE_PYOBJECT]))
+    }
+
+    _PS_BUDDY_OP = DBUS_PATH + "/Buddies/"
+    _PS_SERVICE_OP = DBUS_PATH + "/Services/"
+    _PS_ACTIVITY_OP = DBUS_PATH + "/Activities/"
+    
+
+    def __init__(self):
+        gobject.GObject.__init__(self)
+        self._objcache = ObjectCache()
+        self._bus = dbus.SessionBus()
+        self._ps = dbus.Interface(self._bus.get_object(DBUS_SERVICE,
+                DBUS_PATH), DBUS_INTERFACE)
+        self._ps.connect_to_signal('BuddyAppeared', self._buddy_appeared_cb)
+        self._ps.connect_to_signal('BuddyDisappeared', self._buddy_disappeared_cb)
+        self._ps.connect_to_signal('ServiceAppeared', self._service_appeared_cb)
+        self._ps.connect_to_signal('ServiceDisappeared', self._service_disappeared_cb)
+        self._ps.connect_to_signal('ActivityAppeared', self._activity_appeared_cb)
+        self._ps.connect_to_signal('ActivityDisappeared', self._activity_disappeared_cb)
+
+    def _new_object(self, object_path):
+        obj = self._objcache.get(object_path)
+        if not obj:
+            if object_path.startswith(self._PS_SERVICE_OP):
+                obj = Service.Service(self._bus, self._new_object,
+                        self._del_object, object_path)
+            elif object_path.startswith(self._PS_BUDDY_OP):
+                obj = Buddy.Buddy(self._bus, self._new_object,
+                        self._del_object, object_path)
+            elif object_path.startswith(self._PS_ACTIVITY_OP):
+                obj = Activity.Activity(self._bus, self._new_object,
+                        self._del_object, object_path)
+            else:
+                raise RuntimeError("Unknown object type")
+            self._objcache.add(obj)
+        return obj
+
+    def _del_object(self, object_path):
+        # FIXME
+        pass
+
+    def _emit_buddy_appeared_signal(self, object_path):
+        self.emit('buddy-appeared', self._new_object(object_path))
+        return False
+
+    def _buddy_appeared_cb(self, op):
+        gobject.idle_add(self._emit_buddy_appeared_signal, op)
+
+    def _emit_buddy_disappeared_signal(self, object_path):
+        self.emit('buddy-disappeared', self._new_object(object_path))
+        return False
+
+    def _buddy_disappeared_cb(self, object_path):
+        gobject.idle_add(self._emit_buddy_disappeared_signal, object_path)
+
+    def _emit_service_appeared_signal(self, object_path):
+        self.emit('service-appeared', self._new_object(object_path))
+        return False
+
+    def _service_appeared_cb(self, object_path):
+        gobject.idle_add(self._emit_service_appeared_signal, object_path)
+
+    def _emit_service_disappeared_signal(self, object_path):
+        self.emit('service-disappeared', self._new_object(object_path))
+        return False
+
+    def _service_disappeared_cb(self, object_path):
+        gobject.idle_add(self._emit_service_disappeared_signal, object_path)
+
+    def _emit_activity_appeared_signal(self, object_path):
+        self.emit('activity-appeared', self._new_object(object_path))
+        return False
+
+    def _activity_appeared_cb(self, object_path):
+        gobject.idle_add(self._emit_activity_appeared_signal, object_path)
+
+    def _emit_activity_disappeared_signal(self, object_path):
+        self.emit('activity-disappeared', self._new_object(object_path))
+        return False
+
+    def _activity_disappeared_cb(self, object_path):
+        gobject.idle_add(self._emit_activity_disappeared_signal, object_path)
+
+    def get(self, object_path):
+        return self._new_object(object_path)
+
+    def get_services(self):
+        resp = self._ps.getServices()
+        servs = []
+        for item in resp:
+            servs.append(self._new_object(item))
+        return servs
+
+    def get_services_of_type(self, stype):
+        resp = self._ps.getServicesOfType(stype)
+        servs = []
+        for item in resp:
+            servs.append(self._new_object(item))
+        return servs
+
+    def get_activities(self):
+        resp = self._ps.getActivities()
+        acts = []
+        for item in resp:
+            acts.append(self._new_object(item))
+        return acts
+
+    def get_activity(self, activity_id):
+        try:
+            act_op = self._ps.getActivity(activity_id)
+        except dbus.exceptions.DBusException:
+            return None
+        return self._new_object(act_op)
+
+    def get_buddies(self):
+        resp = self._ps.getBuddies()
+        buddies = []
+        for item in resp:
+            buddies.append(self._new_object(item))
+        return buddies
+
+    def get_buddy_by_name(self, name):
+        try:
+            buddy_op = self._ps.getBuddyByName(name)
+        except dbus.exceptions.DBusException:
+            return None
+        return self._new_object(buddy_op)
+
+    def get_buddy_by_address(self, addr):
+        try:
+            buddy_op = self._ps.getBuddyByAddress(addr)
+        except dbus.exceptions.DBusException:
+            return None
+        return self._new_object(buddy_op)
+
+    def get_owner(self):
+        try:
+            owner_op = self._ps.getOwner()
+        except dbus.exceptions.DBusException:
+            return None
+        return self._new_object(owner_op)
+
+    def share_activity(self, activity, stype, properties={}, address=None, port=-1, domain=u"local"):
+        actid = activity.get_id()
+        if address == None:
+            address = u""
+        serv_op = self._ps.shareActivity(actid, stype, properties, address, port, domain)
+        return self._new_object(serv_op)
+
+    def register_service(self, name, stype, properties={}, address=None, port=-1, domain=u"local"):
+        if address == None:
+            address = u""
+        serv_op = self._ps.registerService(name, stype, properties, address, port, domain)
+        return self._new_object(serv_op)
+
+    def unregister_service(self, service):
+        self._ps.unregisterService(service.object_path())
+
+    def register_service_type(self, stype):
+        self._ps.registerServiceType(stype)
+
+    def unregister_service_type(self, stype):
+        self._ps.unregisterServiceType(stype)
 
 _ps = None
 def get_instance():
-	global _ps
-	if not _ps:
-		_ps = PresenceService()
-	return _ps
+    global _ps
+    if not _ps:
+        _ps = PresenceService()
+    return _ps
 
 
 def start():
-	bus = dbus.SessionBus()
-	ps = dbus.Interface(bus.get_object(DBUS_SERVICE, DBUS_PATH), DBUS_INTERFACE)
-	ps.start()
+    bus = dbus.SessionBus()
+    ps = dbus.Interface(bus.get_object(DBUS_SERVICE, DBUS_PATH), DBUS_INTERFACE)
+    ps.start()
diff --git a/sugar/presence/Service.py b/sugar/presence/Service.py
index a1ef98a..22b436f 100644
--- a/sugar/presence/Service.py
+++ b/sugar/presence/Service.py
@@ -20,101 +20,101 @@ import dbus
 
 
 def _one_dict_differs(dict1, dict2):
-	diff_keys = []
-	for key, value in dict1.items():
-		if not dict2.has_key(key) or dict2[key] != value:
-			diff_keys.append(key)
-	return diff_keys
+    diff_keys = []
+    for key, value in dict1.items():
+        if not dict2.has_key(key) or dict2[key] != value:
+            diff_keys.append(key)
+    return diff_keys
 
 def _dicts_differ(dict1, dict2):
-	diff_keys = []
-	diff1 = _one_dict_differs(dict1, dict2)
-	diff2 = _one_dict_differs(dict2, dict1)
-	for key in diff2:
-		if key not in diff1:
-			diff_keys.append(key)
-	diff_keys += diff1
-	return diff_keys
+    diff_keys = []
+    diff1 = _one_dict_differs(dict1, dict2)
+    diff2 = _one_dict_differs(dict2, dict1)
+    for key in diff2:
+        if key not in diff1:
+            diff_keys.append(key)
+    diff_keys += diff1
+    return diff_keys
 
 class Service(gobject.GObject):
 
-	_PRESENCE_SERVICE = "org.laptop.Presence"
-	_SERVICE_DBUS_INTERFACE = "org.laptop.Presence.Service"
-
-	__gsignals__ = {
-		'published-value-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-								   ([gobject.TYPE_PYOBJECT]))
-	}
-
-	def __init__(self, bus, new_obj_cb, del_obj_cb, object_path):
-		gobject.GObject.__init__(self)
-		self._object_path = object_path
-		self._ps_new_object = new_obj_cb
-		self._ps_del_object = del_obj_cb
-		sobj = bus.get_object(self._PRESENCE_SERVICE, object_path)
-		self._service = dbus.Interface(sobj, self._SERVICE_DBUS_INTERFACE)
-		self._service.connect_to_signal('PropertyChanged', self.__property_changed_cb)
-		self._service.connect_to_signal('PublishedValueChanged',
-				self.__published_value_changed_cb)
-		self._props = self._service.getProperties()
-		self._pubvals = self._service.getPublishedValues()
-
-	def object_path(self):
-		return self._object_path
-
-	def __property_changed_cb(self, prop_list):
-		self._props = self._service.getProperties()
-
-	def get_published_value(self, key):
-		return self._pubvals[key]
-
-	def get_published_values(self):
-		self._pubvals = self._service.getPublishedValues()
-		return self._pubvals
-
-	def set_published_value(self, key, value):
-		if self._pubvals.has_key(key):
-			if self._pubvals[key] == value:
-				return
-		self._pubvals[key] = value
-		self._service.setPublishedValue(key, value)
-
-	def set_published_values(self, vals):
-		self._service.setPublishedValues(vals)
-		self._pubvals = vals
-
-	def __published_value_changed_cb(self, keys):
-		oldvals = self._pubvals
-		self.get_published_values()
-		diff_keys = _dicts_differ(oldvals, self._pubvals)
-		if len(diff_keys) > 0:
-			self.emit('published-value-changed', diff_keys)
-
-	def get_name(self):
-		return self._props['name']
-
-	def get_type(self):
-		return self._props['type']
-
-	def get_domain(self):
-		return self._props['domain']
-
-	def get_address(self):
-		if self._props.has_key('address'):
-			return self._props['address']
-		return None
-
-	def get_activity_id(self):
-		if self._props.has_key('activityId'):
-			return self._props['activityId']
-		return None
-
-	def get_port(self):
-		if self._props.has_key('port'):
-			return self._props['port']
-		return None
-
-	def get_source_address(self):
-		if self._props.has_key('sourceAddress'):
-			return self._props['sourceAddress']
-		return None
+    _PRESENCE_SERVICE = "org.laptop.Presence"
+    _SERVICE_DBUS_INTERFACE = "org.laptop.Presence.Service"
+
+    __gsignals__ = {
+        'published-value-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                                   ([gobject.TYPE_PYOBJECT]))
+    }
+
+    def __init__(self, bus, new_obj_cb, del_obj_cb, object_path):
+        gobject.GObject.__init__(self)
+        self._object_path = object_path
+        self._ps_new_object = new_obj_cb
+        self._ps_del_object = del_obj_cb
+        sobj = bus.get_object(self._PRESENCE_SERVICE, object_path)
+        self._service = dbus.Interface(sobj, self._SERVICE_DBUS_INTERFACE)
+        self._service.connect_to_signal('PropertyChanged', self.__property_changed_cb)
+        self._service.connect_to_signal('PublishedValueChanged',
+                self.__published_value_changed_cb)
+        self._props = self._service.getProperties()
+        self._pubvals = self._service.getPublishedValues()
+
+    def object_path(self):
+        return self._object_path
+
+    def __property_changed_cb(self, prop_list):
+        self._props = self._service.getProperties()
+
+    def get_published_value(self, key):
+        return self._pubvals[key]
+
+    def get_published_values(self):
+        self._pubvals = self._service.getPublishedValues()
+        return self._pubvals
+
+    def set_published_value(self, key, value):
+        if self._pubvals.has_key(key):
+            if self._pubvals[key] == value:
+                return
+        self._pubvals[key] = value
+        self._service.setPublishedValue(key, value)
+
+    def set_published_values(self, vals):
+        self._service.setPublishedValues(vals)
+        self._pubvals = vals
+
+    def __published_value_changed_cb(self, keys):
+        oldvals = self._pubvals
+        self.get_published_values()
+        diff_keys = _dicts_differ(oldvals, self._pubvals)
+        if len(diff_keys) > 0:
+            self.emit('published-value-changed', diff_keys)
+
+    def get_name(self):
+        return self._props['name']
+
+    def get_type(self):
+        return self._props['type']
+
+    def get_domain(self):
+        return self._props['domain']
+
+    def get_address(self):
+        if self._props.has_key('address'):
+            return self._props['address']
+        return None
+
+    def get_activity_id(self):
+        if self._props.has_key('activityId'):
+            return self._props['activityId']
+        return None
+
+    def get_port(self):
+        if self._props.has_key('port'):
+            return self._props['port']
+        return None
+
+    def get_source_address(self):
+        if self._props.has_key('sourceAddress'):
+            return self._props['sourceAddress']
+        return None