Changed all tabs to 4 spaces for python style

26 files changed, 1414 insertions, 1414 deletions

diff --git a/shell/view/ActivityHost.py b/shell/view/ActivityHost.py
index a7e177d..f87b65b 100644
--- a/shell/view/ActivityHost.py
+++ b/shell/view/ActivityHost.py
@@ -27,122 +27,122 @@ from sugar.chat import ActivityChat
 import OverlayWindow
 
 class ActivityChatWindow(gtk.Window):
-	def __init__(self, gdk_window, chat_widget):
-		gtk.Window.__init__(self)
+    def __init__(self, gdk_window, chat_widget):
+        gtk.Window.__init__(self)
 
-		self.realize()
-		self.set_decorated(False)
-		self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
-		self.window.set_accept_focus(True)		
-		self.window.set_transient_for(gdk_window)
-		self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
-		self.set_default_size(600, 450)
+        self.realize()
+        self.set_decorated(False)
+        self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
+        self.window.set_accept_focus(True)        
+        self.window.set_transient_for(gdk_window)
+        self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
+        self.set_default_size(600, 450)
 
-		self.add(chat_widget)
+        self.add(chat_widget)
 
 class ActivityHost:
-	def __init__(self, shell_model, window):
-		self._window = window
-		self._xid = window.get_xid()
-		self._pservice = PresenceService.get_instance()
-
-		bus = dbus.SessionBus()
-		proxy_obj = bus.get_object(Activity.get_service_name(self._xid),
-								   Activity.get_object_path(self._xid))
-
-		self._activity = dbus.Interface(proxy_obj, Activity.ACTIVITY_INTERFACE)
-		self._id = self._activity.get_id()
-		self._type = self._activity.get_type()
-		self._gdk_window = gtk.gdk.window_foreign_new(self._xid)
-
-		registry = shell_model.get_bundle_registry()
-		info = registry.get_bundle(self._type)
-		self._icon_name = info.get_icon()
-
-		try:
-			self._overlay_window = OverlayWindow.OverlayWindow(self._gdk_window)
-			win = self._overlay_window.window
-		except RuntimeError:
-			self._overlay_window = None
-			win = self._gdk_window
-
-		self._chat_widget = ActivityChat.ActivityChat(self)
-		self._chat_window = ActivityChatWindow(win, self._chat_widget)
-
-		self._frame_was_visible = False
-
-	def get_id(self):
-		return self._id
-
-	def get_title(self):
-		return self._window.get_name()
-
-	def get_xid(self):
-		return self._xid
-
-	def get_icon_name(self):
-		return self._icon_name
-
-	def get_icon_color(self):
-		activity = self._pservice.get_activity(self._id)
-		if activity != None:
-			return IconColor(activity.get_color())
-		else:
-			return profile.get_color()
-
-	def share(self):
-		self._activity.share()
-		self._chat_widget.share()
-
-	def invite(self, buddy):
-		if not self.get_shared():
-			self.share()
-
-		issuer = self._pservice.get_owner().get_name()
-		service = buddy.get_service_of_type("_presence_olpc._tcp")
-		stream = Stream.Stream.new_from_service(service, start_reader=False)
-		writer = stream.new_writer(service)
-		writer.custom_request("invite", None, None, issuer,
-							  self._type, self._id)
-
-	def get_shared(self):
-		return self._activity.get_shared()
-
-	def get_type(self):
-		return self._type
-
-	def present(self):
-		self._window.activate(gtk.get_current_event_time())
-
-	def close(self):
-		self._window.close(gtk.get_current_event_time())
-
-	def show_dialog(self, dialog):
-		dialog.show()
-		dialog.window.set_transient_for(self._gdk_window)
-
-	def chat_show(self, frame_was_visible):
-		if self._overlay_window:
-			self._overlay_window.show_all()
-		self._chat_window.show_all()
-		self._frame_was_visible = frame_was_visible
-
-	def chat_hide(self):
-		self._chat_window.hide()
-		if self._overlay_window:
-			self._overlay_window.hide()
-		wasvis = self._frame_was_visible
-		self._frame_was_visible = False
-		return wasvis
-
-	def is_chat_visible(self):
-		return self._chat_window.get_property('visible')
-
-	def set_active(self, active):
-		if not active:
-			self.chat_hide()
-			self._frame_was_visible = False
-
-	def destroy(self):
-		self._chat_window.destroy()
-		self._frame_was_visible = False
+    def __init__(self, shell_model, window):
+        self._window = window
+        self._xid = window.get_xid()
+        self._pservice = PresenceService.get_instance()
+
+        bus = dbus.SessionBus()
+        proxy_obj = bus.get_object(Activity.get_service_name(self._xid),
+                                   Activity.get_object_path(self._xid))
+
+        self._activity = dbus.Interface(proxy_obj, Activity.ACTIVITY_INTERFACE)
+        self._id = self._activity.get_id()
+        self._type = self._activity.get_type()
+        self._gdk_window = gtk.gdk.window_foreign_new(self._xid)
+
+        registry = shell_model.get_bundle_registry()
+        info = registry.get_bundle(self._type)
+        self._icon_name = info.get_icon()
+
+        try:
+            self._overlay_window = OverlayWindow.OverlayWindow(self._gdk_window)
+            win = self._overlay_window.window
+        except RuntimeError:
+            self._overlay_window = None
+            win = self._gdk_window
+
+        self._chat_widget = ActivityChat.ActivityChat(self)
+        self._chat_window = ActivityChatWindow(win, self._chat_widget)
+
+        self._frame_was_visible = False
+
+    def get_id(self):
+        return self._id
+
+    def get_title(self):
+        return self._window.get_name()
+
+    def get_xid(self):
+        return self._xid
+
+    def get_icon_name(self):
+        return self._icon_name
+
+    def get_icon_color(self):
+        activity = self._pservice.get_activity(self._id)
+        if activity != None:
+            return IconColor(activity.get_color())
+        else:
+            return profile.get_color()
+
+    def share(self):
+        self._activity.share()
+        self._chat_widget.share()
+
+    def invite(self, buddy):
+        if not self.get_shared():
+            self.share()
+
+        issuer = self._pservice.get_owner().get_name()
+        service = buddy.get_service_of_type("_presence_olpc._tcp")
+        stream = Stream.Stream.new_from_service(service, start_reader=False)
+        writer = stream.new_writer(service)
+        writer.custom_request("invite", None, None, issuer,
+                              self._type, self._id)
+
+    def get_shared(self):
+        return self._activity.get_shared()
+
+    def get_type(self):
+        return self._type
+
+    def present(self):
+        self._window.activate(gtk.get_current_event_time())
+
+    def close(self):
+        self._window.close(gtk.get_current_event_time())
+
+    def show_dialog(self, dialog):
+        dialog.show()
+        dialog.window.set_transient_for(self._gdk_window)
+
+    def chat_show(self, frame_was_visible):
+        if self._overlay_window:
+            self._overlay_window.show_all()
+        self._chat_window.show_all()
+        self._frame_was_visible = frame_was_visible
+
+    def chat_hide(self):
+        self._chat_window.hide()
+        if self._overlay_window:
+            self._overlay_window.hide()
+        wasvis = self._frame_was_visible
+        self._frame_was_visible = False
+        return wasvis
+
+    def is_chat_visible(self):
+        return self._chat_window.get_property('visible')
+
+    def set_active(self, active):
+        if not active:
+            self.chat_hide()
+            self._frame_was_visible = False
+
+    def destroy(self):
+        self._chat_window.destroy()
+        self._frame_was_visible = False
diff --git a/shell/view/BuddyIcon.py b/shell/view/BuddyIcon.py
index f8f1013..38f8277 100644
--- a/shell/view/BuddyIcon.py
+++ b/shell/view/BuddyIcon.py
@@ -18,41 +18,41 @@ from sugar.graphics.menuicon import MenuIcon
 from view.BuddyMenu import BuddyMenu
 
 class BuddyIcon(MenuIcon):
-	def __init__(self, shell, menu_shell, buddy):
-		MenuIcon.__init__(self, menu_shell, icon_name='stock-buddy',
-						  color=buddy.get_color())
-
-		self._shell = shell
-		self._buddy = buddy
-		self._buddy.connect('appeared', self._buddy_presence_change_cb)
-		self._buddy.connect('disappeared', self._buddy_presence_change_cb)
-		self._buddy.connect('color-changed', self._buddy_presence_change_cb)
-
-	def _buddy_presence_change_cb(self, buddy, color=None):
-		# Update the icon's color when the buddy comes and goes
-		self.set_property('color', buddy.get_color())
-
-	def set_popup_distance(self, distance):
-		self._popup_distance = distance
-
-	def create_menu(self):
-		menu = BuddyMenu(self._shell, self._buddy)
-		menu.connect('action', self._popup_action_cb)
-		return menu
-
-	def _popup_action_cb(self, popup, action):
-		self.popdown()
-
-		friends = self._shell.get_model().get_friends()
-		if action == BuddyMenu.ACTION_REMOVE_FRIEND:
-			friends.remove(self._buddy)
-
-		ps_buddy = self._buddy.get_buddy()
-		if ps_buddy == None:
-			return
-
-		if action == BuddyMenu.ACTION_INVITE:
-			activity = self._shell.get_current_activity()
-			activity.invite(ps_buddy)
-		elif action == BuddyMenu.ACTION_MAKE_FRIEND:
-			friends.make_friend(ps_buddy)
+    def __init__(self, shell, menu_shell, buddy):
+        MenuIcon.__init__(self, menu_shell, icon_name='stock-buddy',
+                          color=buddy.get_color())
+
+        self._shell = shell
+        self._buddy = buddy
+        self._buddy.connect('appeared', self._buddy_presence_change_cb)
+        self._buddy.connect('disappeared', self._buddy_presence_change_cb)
+        self._buddy.connect('color-changed', self._buddy_presence_change_cb)
+
+    def _buddy_presence_change_cb(self, buddy, color=None):
+        # Update the icon's color when the buddy comes and goes
+        self.set_property('color', buddy.get_color())
+
+    def set_popup_distance(self, distance):
+        self._popup_distance = distance
+
+    def create_menu(self):
+        menu = BuddyMenu(self._shell, self._buddy)
+        menu.connect('action', self._popup_action_cb)
+        return menu
+
+    def _popup_action_cb(self, popup, action):
+        self.popdown()
+
+        friends = self._shell.get_model().get_friends()
+        if action == BuddyMenu.ACTION_REMOVE_FRIEND:
+            friends.remove(self._buddy)
+
+        ps_buddy = self._buddy.get_buddy()
+        if ps_buddy == None:
+            return
+
+        if action == BuddyMenu.ACTION_INVITE:
+            activity = self._shell.get_current_activity()
+            activity.invite(ps_buddy)
+        elif action == BuddyMenu.ACTION_MAKE_FRIEND:
+            friends.make_friend(ps_buddy)
diff --git a/shell/view/BuddyMenu.py b/shell/view/BuddyMenu.py
index f330234..069aa6a 100644
--- a/shell/view/BuddyMenu.py
+++ b/shell/view/BuddyMenu.py
@@ -25,73 +25,73 @@ from sugar.presence import PresenceService
 _ICON_SIZE = 75
 
 class BuddyMenu(Menu):
-	ACTION_MAKE_FRIEND = 0
-	ACTION_INVITE = 1
-	ACTION_REMOVE_FRIEND = 2
-
-	def __init__(self, shell, buddy):
-		self._buddy = buddy
-		self._shell = shell
-
-		icon_item = None
-		pixbuf = self._get_buddy_icon_pixbuf()
-		if pixbuf:
-			scaled_pixbuf = pixbuf.scale_simple(_ICON_SIZE, _ICON_SIZE,
-												gtk.gdk.INTERP_BILINEAR)
-			del pixbuf
-			icon_item = hippo.CanvasImage(pixbuf=scaled_pixbuf)
-
-		Menu.__init__(self, buddy.get_name(), icon_item)
-
-		self._buddy.connect('icon-changed', self.__buddy_icon_changed_cb)
-
-		owner = shell.get_model().get_owner()
-		if buddy.get_name() != owner.get_name():
-			self._add_actions()
-
-	def _get_buddy_icon_pixbuf(self):
-		buddy_object = self._buddy.get_buddy()
-		if not buddy_object:
-			return None
-
-		pixbuf = None
-		icon_data = buddy_object.get_icon()
-		icon_data_string = ""
-		for item in icon_data:
-			if item < 0:
-				item = item + 128
-			icon_data_string += chr(item)
-		pbl = gtk.gdk.PixbufLoader()
-		pbl.write(icon_data_string)
-		try:
-			pbl.close()
-			pixbuf = pbl.get_pixbuf()
-		except gobject.GError:
-			pass
-		del pbl
-		return pixbuf
-
-	def _add_actions(self):
-		shell_model = self._shell.get_model()
-		pservice = PresenceService.get_instance()
-
-		friends = shell_model.get_friends()
-		if friends.has_buddy(self._buddy):
-			icon = CanvasIcon(icon_name='stock-remove')
-			self.add_action(icon, BuddyMenu.ACTION_REMOVE_FRIEND) 
-		else:
-			icon = CanvasIcon(icon_name='stock-add')
-			self.add_action(icon, BuddyMenu.ACTION_MAKE_FRIEND)
-
-		activity_id = shell_model.get_current_activity()
-		if activity_id != None:
-			activity_ps = pservice.get_activity(activity_id)
-
-			# FIXME check that the buddy is not in the activity already
-
-			icon = CanvasIcon(icon_name='stock-invite')
-			self.add_action(icon, BuddyMenu.ACTION_INVITE)
-
-	def __buddy_icon_changed_cb(self, buddy):
-		pass
+    ACTION_MAKE_FRIEND = 0
+    ACTION_INVITE = 1
+    ACTION_REMOVE_FRIEND = 2
+
+    def __init__(self, shell, buddy):
+        self._buddy = buddy
+        self._shell = shell
+
+        icon_item = None
+        pixbuf = self._get_buddy_icon_pixbuf()
+        if pixbuf:
+            scaled_pixbuf = pixbuf.scale_simple(_ICON_SIZE, _ICON_SIZE,
+                                                gtk.gdk.INTERP_BILINEAR)
+            del pixbuf
+            icon_item = hippo.CanvasImage(pixbuf=scaled_pixbuf)
+
+        Menu.__init__(self, buddy.get_name(), icon_item)
+
+        self._buddy.connect('icon-changed', self.__buddy_icon_changed_cb)
+
+        owner = shell.get_model().get_owner()
+        if buddy.get_name() != owner.get_name():
+            self._add_actions()
+
+    def _get_buddy_icon_pixbuf(self):
+        buddy_object = self._buddy.get_buddy()
+        if not buddy_object:
+            return None
+
+        pixbuf = None
+        icon_data = buddy_object.get_icon()
+        icon_data_string = ""
+        for item in icon_data:
+            if item < 0:
+                item = item + 128
+            icon_data_string += chr(item)
+        pbl = gtk.gdk.PixbufLoader()
+        pbl.write(icon_data_string)
+        try:
+            pbl.close()
+            pixbuf = pbl.get_pixbuf()
+        except gobject.GError:
+            pass
+        del pbl
+        return pixbuf
+
+    def _add_actions(self):
+        shell_model = self._shell.get_model()
+        pservice = PresenceService.get_instance()
+
+        friends = shell_model.get_friends()
+        if friends.has_buddy(self._buddy):
+            icon = CanvasIcon(icon_name='stock-remove')
+            self.add_action(icon, BuddyMenu.ACTION_REMOVE_FRIEND) 
+        else:
+            icon = CanvasIcon(icon_name='stock-add')
+            self.add_action(icon, BuddyMenu.ACTION_MAKE_FRIEND)
+
+        activity_id = shell_model.get_current_activity()
+        if activity_id != None:
+            activity_ps = pservice.get_activity(activity_id)
+
+            # FIXME check that the buddy is not in the activity already
+
+            icon = CanvasIcon(icon_name='stock-invite')
+            self.add_action(icon, BuddyMenu.ACTION_INVITE)
+
+    def __buddy_icon_changed_cb(self, buddy):
+        pass
 
diff --git a/shell/view/ClipboardIcon.py b/shell/view/ClipboardIcon.py
index 429fc99..41f3e09 100644
--- a/shell/view/ClipboardIcon.py
+++ b/shell/view/ClipboardIcon.py
@@ -5,34 +5,34 @@ from sugar.clipboard import ClipboardService
 
 class ClipboardIcon(MenuIcon):
 
-	def __init__(self, menu_shell, name, file_name):
-		MenuIcon.__init__(self, menu_shell, icon_name='activity-xbook')
-		self._name = name
-		self._file_name = file_name
-		self._percent = 0
-		self.connect('activated', self._icon_activated_cb)
-		self._menu = None
-		
-	def create_menu(self):
-		self._menu = ClipboardMenu(self._name, self._percent)
-		self._menu.connect('action', self._popup_action_cb)
-		return self._menu
+    def __init__(self, menu_shell, name, file_name):
+        MenuIcon.__init__(self, menu_shell, icon_name='activity-xbook')
+        self._name = name
+        self._file_name = file_name
+        self._percent = 0
+        self.connect('activated', self._icon_activated_cb)
+        self._menu = None
+        
+    def create_menu(self):
+        self._menu = ClipboardMenu(self._name, self._percent)
+        self._menu.connect('action', self._popup_action_cb)
+        return self._menu
 
-	def set_percent(self, percent):
-		self._percent = percent
-		if self._menu:
-			self._menu.set_percent(percent)
+    def set_percent(self, percent):
+        self._percent = percent
+        if self._menu:
+            self._menu.set_percent(percent)
 
-	def _icon_activated_cb(self, icon):
-		if self._percent == 100:
-			activity = ActivityFactory.create("org.laptop.sugar.Xbook")
-			activity.execute("open_document", [self._file_name])
+    def _icon_activated_cb(self, icon):
+        if self._percent == 100:
+            activity = ActivityFactory.create("org.laptop.sugar.Xbook")
+            activity.execute("open_document", [self._file_name])
 
-	def _popup_action_cb(self, popup, action):
-		self.popdown()
-		
-		if action == ClipboardMenu.ACTION_STOP_DOWNLOAD:
-			raise "Stopping downloads still not implemented."
-		elif action == ClipboardMenu.ACTION_DELETE:
-			cb_service = ClipboardService.get_instance()
-			cb_service.delete_object(self._file_name)
+    def _popup_action_cb(self, popup, action):
+        self.popdown()
+        
+        if action == ClipboardMenu.ACTION_STOP_DOWNLOAD:
+            raise "Stopping downloads still not implemented."
+        elif action == ClipboardMenu.ACTION_DELETE:
+            cb_service = ClipboardService.get_instance()
+            cb_service.delete_object(self._file_name)
diff --git a/shell/view/ClipboardMenu.py b/shell/view/ClipboardMenu.py
index 44ca798..625c897 100644
--- a/shell/view/ClipboardMenu.py
+++ b/shell/view/ClipboardMenu.py
@@ -9,48 +9,48 @@ from sugar.graphics import style
 
 class ClipboardMenuItem(ClipboardBubble):
 
-	def __init__(self, percent = 0, stylesheet="clipboard.Bubble"):
-		ClipboardBubble.__init__(self, percent = percent)
-		style.apply_stylesheet(self, stylesheet)
+    def __init__(self, percent = 0, stylesheet="clipboard.Bubble"):
+        ClipboardBubble.__init__(self, percent = percent)
+        style.apply_stylesheet(self, stylesheet)
 
 class ClipboardMenu(Menu):
 
-	ACTION_DELETE = 0
-	ACTION_SHARE = 1
-	ACTION_STOP_DOWNLOAD = 2
-	
-	def __init__(self, name, percent):
-		Menu.__init__(self, name)
-		
-		self._progress_bar = ClipboardMenuItem(percent)
-		self._root.append(self._progress_bar)
-				
-		#icon = CanvasIcon(icon_name='stock-share-mesh')
-		#self.add_action(icon, ClipboardMenu.ACTION_SHARE)
-		
-		self._remove_icon = None
-		self._stop_icon = None
-		
-		self._create_icons(percent)
-		
-	def _create_icons(self, percent):			
-		if percent == 100:
-			if not self._remove_icon:
-				self._remove_icon = CanvasIcon(icon_name='stock-remove')
-				self.add_action(self._remove_icon, ClipboardMenu.ACTION_DELETE)
-			
-			if self._stop_icon:
-				self.remove_action(self._stop_icon)
-				self._stop_icon = None
-		else:
-			if not self._stop_icon:
-				self._stop_icon = CanvasIcon(icon_name='stock-close')
-				self.add_action(self._stop_icon, ClipboardMenu.ACTION_STOP_DOWNLOAD)
+    ACTION_DELETE = 0
+    ACTION_SHARE = 1
+    ACTION_STOP_DOWNLOAD = 2
+    
+    def __init__(self, name, percent):
+        Menu.__init__(self, name)
+        
+        self._progress_bar = ClipboardMenuItem(percent)
+        self._root.append(self._progress_bar)
+                
+        #icon = CanvasIcon(icon_name='stock-share-mesh')
+        #self.add_action(icon, ClipboardMenu.ACTION_SHARE)
+        
+        self._remove_icon = None
+        self._stop_icon = None
+        
+        self._create_icons(percent)
+        
+    def _create_icons(self, percent):            
+        if percent == 100:
+            if not self._remove_icon:
+                self._remove_icon = CanvasIcon(icon_name='stock-remove')
+                self.add_action(self._remove_icon, ClipboardMenu.ACTION_DELETE)
+            
+            if self._stop_icon:
+                self.remove_action(self._stop_icon)
+                self._stop_icon = None
+        else:
+            if not self._stop_icon:
+                self._stop_icon = CanvasIcon(icon_name='stock-close')
+                self.add_action(self._stop_icon, ClipboardMenu.ACTION_STOP_DOWNLOAD)
 
-			if self._remove_icon:
-				self.remove_action(self._remove_icon)
-				self._remove_icon = None
-	
-	def set_percent(self, percent):
-		self._progress_bar.set_property('percent', percent)
-		self._create_icons(percent)
+            if self._remove_icon:
+                self.remove_action(self._remove_icon)
+                self._remove_icon = None
+    
+    def set_percent(self, percent):
+        self._progress_bar.set_property('percent', percent)
+        self._create_icons(percent)
diff --git a/shell/view/FirstTimeDialog.py b/shell/view/FirstTimeDialog.py
index 267a661..0ae82ef 100644
--- a/shell/view/FirstTimeDialog.py
+++ b/shell/view/FirstTimeDialog.py
@@ -24,47 +24,47 @@ from sugar.graphics.iconcolor import IconColor
 from sugar import env
 
 class FirstTimeDialog(gtk.Dialog):
-	def __init__(self):
-		gtk.Dialog.__init__(self)
+    def __init__(self):
+        gtk.Dialog.__init__(self)
 
-		label = gtk.Label(_('Nick Name:'))
-		label.set_alignment(0.0, 0.5)
-		self.vbox.pack_start(label)
-		label.show()
+        label = gtk.Label(_('Nick Name:'))
+        label.set_alignment(0.0, 0.5)
+        self.vbox.pack_start(label)
+        label.show()
 
-		self._entry = gtk.Entry()
-		self._entry.connect('changed', self._entry_changed_cb)
-		self._entry.connect('activate', self._entry_activated_cb)
-		self.vbox.pack_start(self._entry)
-		self._entry.show()
+        self._entry = gtk.Entry()
+        self._entry.connect('changed', self._entry_changed_cb)
+        self._entry.connect('activate', self._entry_activated_cb)
+        self.vbox.pack_start(self._entry)
+        self._entry.show()
 
-		self._ok = gtk.Button(None, gtk.STOCK_OK)
-		self._ok.set_sensitive(False)
-		self.vbox.pack_start(self._ok)
-		self._ok.connect('clicked', self._ok_button_clicked_cb)
-		self._ok.show()
+        self._ok = gtk.Button(None, gtk.STOCK_OK)
+        self._ok.set_sensitive(False)
+        self.vbox.pack_start(self._ok)
+        self._ok.connect('clicked', self._ok_button_clicked_cb)
+        self._ok.show()
 
-	def _entry_changed_cb(self, entry):
-		valid = (len(entry.get_text()) > 0)
-		self._ok.set_sensitive(valid)
+    def _entry_changed_cb(self, entry):
+        valid = (len(entry.get_text()) > 0)
+        self._ok.set_sensitive(valid)
 
-	def _entry_activated_cb(self, entry):
-		self._create_buddy_section()
-		
-	def _ok_button_clicked_cb(self, button):
-		self._create_buddy_section()
-		
-	def _create_buddy_section(self):
-		cp = ConfigParser()
+    def _entry_activated_cb(self, entry):
+        self._create_buddy_section()
+        
+    def _ok_button_clicked_cb(self, button):
+        self._create_buddy_section()
+        
+    def _create_buddy_section(self):
+        cp = ConfigParser()
 
-		section = 'Buddy'	
-		cp.add_section(section)
-		cp.set(section, 'NickName', self._entry.get_text())
-		cp.set(section, 'Color', IconColor().to_string())
+        section = 'Buddy'    
+        cp.add_section(section)
+        cp.set(section, 'NickName', self._entry.get_text())
+        cp.set(section, 'Color', IconColor().to_string())
 
-		config_path = os.path.join(env.get_profile_path(), 'config')
-		fileobject = open(config_path, 'w')
-		cp.write(fileobject)
-		fileobject.close()
+        config_path = os.path.join(env.get_profile_path(), 'config')
+        fileobject = open(config_path, 'w')
+        cp.write(fileobject)
+        fileobject.close()
 
-		self.destroy()
+        self.destroy()
diff --git a/shell/view/OverlayWindow.py b/shell/view/OverlayWindow.py
index 93719a7..7980a1d 100644
--- a/shell/view/OverlayWindow.py
+++ b/shell/view/OverlayWindow.py
@@ -19,32 +19,32 @@ import cairo
 
 
 class OverlayWindow(gtk.Window):
-	def __init__(self, lower_window):
-		gtk.Window.__init__(self)
-
-		colormap = self.get_screen().get_rgba_colormap()
-		colormap=None
-		if not colormap:
-			raise RuntimeError("The window manager doesn't support compositing.")
-		self.set_colormap(colormap)
-
-		self.realize()
-
-		self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
-		self.window.set_accept_focus(False)
-		self.window.set_transient_for(lower_window)
-
-		self.set_decorated(False)
-		self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
-		self.set_default_size(gtk.gdk.screen_width(), gtk.gdk.screen_height())
-		self.set_app_paintable(True)
-
-		self.connect('expose-event', self._expose_cb)
-
-	def _expose_cb(self, widget, event):
-		cr = widget.window.cairo_create()
-		cr.set_source_rgba(0.0, 0.0, 0.0, 0.4) # Transparent
-		cr.set_operator(cairo.OPERATOR_SOURCE)
-		cr.paint()
-		return False
+    def __init__(self, lower_window):
+        gtk.Window.__init__(self)
+
+        colormap = self.get_screen().get_rgba_colormap()
+        colormap=None
+        if not colormap:
+            raise RuntimeError("The window manager doesn't support compositing.")
+        self.set_colormap(colormap)
+
+        self.realize()
+
+        self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
+        self.window.set_accept_focus(False)
+        self.window.set_transient_for(lower_window)
+
+        self.set_decorated(False)
+        self.set_position(gtk.WIN_POS_CENTER_ALWAYS)
+        self.set_default_size(gtk.gdk.screen_width(), gtk.gdk.screen_height())
+        self.set_app_paintable(True)
+
+        self.connect('expose-event', self._expose_cb)
+
+    def _expose_cb(self, widget, event):
+        cr = widget.window.cairo_create()
+        cr.set_source_rgba(0.0, 0.0, 0.0, 0.4) # Transparent
+        cr.set_operator(cairo.OPERATOR_SOURCE)
+        cr.paint()
+        return False
 
diff --git a/shell/view/Shell.py b/shell/view/Shell.py
index 585f480..9166cef 100644
--- a/shell/view/Shell.py
+++ b/shell/view/Shell.py
@@ -31,206 +31,206 @@ from _sugar import KeyGrabber
 import sugar
 
 class Shell(gobject.GObject):
-	__gsignals__ = {
-		'activity-opened':  (gobject.SIGNAL_RUN_FIRST,
-							 gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT])),
-		'activity-changed': (gobject.SIGNAL_RUN_FIRST,
-							 gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT])),
-		'activity-closed':  (gobject.SIGNAL_RUN_FIRST,
-							 gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT]))
-	}
-
-	def __init__(self, model):
-		gobject.GObject.__init__(self)
-
-		self._model = model
-		self._hosts = {}
-		self._screen = wnck.screen_get_default()
-		self._current_host = None
-
-		style.load_stylesheet(view.stylesheet)
-
-		self._dcon_manager = DCONManager()
-
-		self._key_grabber = KeyGrabber()
-		self._key_grabber.connect('key-pressed',
-								  self.__global_key_pressed_cb)
-		self._key_grabber.connect('key-released',
-								  self.__global_key_released_cb)
-		self._key_grabber.grab('F1')
-		self._key_grabber.grab('F2')
-		self._key_grabber.grab('F3')
-		self._key_grabber.grab('F4')
-		self._key_grabber.grab('F5')
-		self._key_grabber.grab('F6')
-		self._key_grabber.grab('F7')
-		self._key_grabber.grab('F8')
-		self._key_grabber.grab('0xDC') # Camera key
-		self._key_grabber.grab('0xE0') # Overlay key
-		self._key_grabber.grab('0x93') # Frame key
-
-		# For non-OLPC machines
-		self._key_grabber.grab('<shft><alt>F9')
-		self._key_grabber.grab('<shft><alt>F10')
-		self._key_grabber.grab('<shft><alt>F11')
-
-		self._home_window = HomeWindow(self)
-		self._home_window.show()
-		self.set_zoom_level(sugar.ZOOM_HOME)
-
-		self._screen.connect('window-opened', self.__window_opened_cb)
-		self._screen.connect('window-closed', self.__window_closed_cb)
-		self._screen.connect('active-window-changed',
-							 self.__active_window_changed_cb)
-
-		self._frame = Frame(self)
-		self._frame.show_and_hide(3)
-
-	def _open_terminal_cb(self):
-		self.start_activity('org.sugar.Terminal')
-		return False
-
-	def __global_key_pressed_cb(self, grabber, key):
-		if key == 'F1':
-			self.set_zoom_level(sugar.ZOOM_MESH)
-		elif key == 'F2':
-			self.set_zoom_level(sugar.ZOOM_FRIENDS)
-		elif key == 'F3':
-			self.set_zoom_level(sugar.ZOOM_HOME)
-		elif key == 'F4':
-			self.set_zoom_level(sugar.ZOOM_ACTIVITY)
-		elif key == 'F5':
-			self._dcon_manager.decrease_brightness()
-		elif key == 'F6':
-			self._dcon_manager.increase_brightness()
-		elif key == 'F7':
-			self._dcon_manager.set_mode(DCONManager.COLOR_MODE)
-		elif key == 'F8':
-			self._dcon_manager.set_mode(DCONManager.BLACK_AND_WHITE_MODE)
-		elif key == '<shft><alt>F9':
-			self._frame.notify_key_press()
-		elif key == '<shft><alt>F10':
-			self.toggle_chat_visibility()
-		elif key == '<shft><alt>F11':
-			gobject.idle_add(self._open_terminal_cb)
-		elif key == '0xDC': # Camera key
-			pass
-		elif key == '0xE0': # Overlay key
-			self.toggle_chat_visibility()
-		elif key == '0x93': # Frame key
-			self._frame.notify_key_press()
-
-	def __global_key_released_cb(self, grabber, key):
-		if key == '<shft><alt>F9':
-			self._frame.notify_key_release()
-		elif key == '0x93':
-			self._frame.notify_key_release()
-
-	def __window_opened_cb(self, screen, window):
-		if window.get_window_type() == wnck.WINDOW_NORMAL:
-			activity_host = ActivityHost(self.get_model(), window)
-			self._hosts[activity_host.get_xid()] = activity_host
-			self.emit('activity-opened', activity_host)
-
-	def __active_window_changed_cb(self, screen):
-		window = screen.get_active_window()
-		if not window or window.get_window_type() != wnck.WINDOW_NORMAL:
-			return
-		if not self._hosts.has_key(window.get_xid()):
-			return
-
-		activity_host = self._hosts[window.get_xid()]
-		current = self._model.get_current_activity()
-		if activity_host.get_id() == current:
-			return
-
-		self._set_current_activity(activity_host)
-
-	def __window_closed_cb(self, screen, window):
-		if window.get_window_type() != wnck.WINDOW_NORMAL:
-			return
-
-		if not self._hosts.has_key(window.get_xid()):
-			return
-
-		host = self._hosts[window.get_xid()]
-		host.destroy()
-
-		self.emit('activity-closed', host)
-		del self._hosts[window.get_xid()]
-
-		if len(self._hosts) == 0:
-			self._set_current_activity(None)
-
-	def _set_current_activity(self, host):
-		if host:
-			self._model.set_current_activity(host.get_id())
-		else:
-			self._model.set_current_activity(None)
-
-		if self._current_host:
-			self._current_host.set_active(False)
-
-		self._current_host = host
-
-		if self._current_host:
-			self._current_host.set_active(True)
-
-		self.emit('activity-changed', host)
-
-	def get_model(self):
-		return self._model
-
-	def join_activity(self, bundle_id, activity_id):
-		pservice = PresenceService.get_instance()
-
-		activity = self._get_activity(activity_id)
-		if activity:
-			activity.present()
-		else:
-			activity_ps = pservice.get_activity(activity_id)
-
-			if activity_ps:
-				activity = ActivityFactory.create(bundle_id)
-				activity.join(activity_ps.object_path())
-			else:
-				logging.error('Cannot start activity.')
-
-	def start_activity(self, activity_type):
-		activity = ActivityFactory.create(activity_type)
-		activity.execute('test', [])
-		return activity
-
-	def set_zoom_level(self, level):
-		if level == sugar.ZOOM_ACTIVITY:
-			self._screen.toggle_showing_desktop(False)
-		else:
-			self._screen.toggle_showing_desktop(True)
-			self._home_window.set_zoom_level(level)
-
-	def get_current_activity(self):
-		activity_id = self._model.get_current_activity()
-		if activity_id:
-			return self._get_activity(activity_id)
-		else:
-			return None
-
-	def _get_activity(self, activity_id):
-		for host in self._hosts.values():
-			if host.get_id() == activity_id:
-				return host
-		return None
-
-	def toggle_chat_visibility(self):
-		act = self.get_current_activity()
-		if not act:
-			return
-		is_visible = self._frame.is_visible()
-		if act.is_chat_visible():
-			frame_was_visible = act.chat_hide()
-			if not frame_was_visible:
-				self._frame.do_slide_out()
-		else:
-			if not is_visible:
-				self._frame.do_slide_in()
-			act.chat_show(is_visible)
+    __gsignals__ = {
+        'activity-opened':  (gobject.SIGNAL_RUN_FIRST,
+                             gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT])),
+        'activity-changed': (gobject.SIGNAL_RUN_FIRST,
+                             gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT])),
+        'activity-closed':  (gobject.SIGNAL_RUN_FIRST,
+                             gobject.TYPE_NONE, ([gobject.TYPE_PYOBJECT]))
+    }
+
+    def __init__(self, model):
+        gobject.GObject.__init__(self)
+
+        self._model = model
+        self._hosts = {}
+        self._screen = wnck.screen_get_default()
+        self._current_host = None
+
+        style.load_stylesheet(view.stylesheet)
+
+        self._dcon_manager = DCONManager()
+
+        self._key_grabber = KeyGrabber()
+        self._key_grabber.connect('key-pressed',
+                                  self.__global_key_pressed_cb)
+        self._key_grabber.connect('key-released',
+                                  self.__global_key_released_cb)
+        self._key_grabber.grab('F1')
+        self._key_grabber.grab('F2')
+        self._key_grabber.grab('F3')
+        self._key_grabber.grab('F4')
+        self._key_grabber.grab('F5')
+        self._key_grabber.grab('F6')
+        self._key_grabber.grab('F7')
+        self._key_grabber.grab('F8')
+        self._key_grabber.grab('0xDC') # Camera key
+        self._key_grabber.grab('0xE0') # Overlay key
+        self._key_grabber.grab('0x93') # Frame key
+
+        # For non-OLPC machines
+        self._key_grabber.grab('<shft><alt>F9')
+        self._key_grabber.grab('<shft><alt>F10')
+        self._key_grabber.grab('<shft><alt>F11')
+
+        self._home_window = HomeWindow(self)
+        self._home_window.show()
+        self.set_zoom_level(sugar.ZOOM_HOME)
+
+        self._screen.connect('window-opened', self.__window_opened_cb)
+        self._screen.connect('window-closed', self.__window_closed_cb)
+        self._screen.connect('active-window-changed',
+                             self.__active_window_changed_cb)
+
+        self._frame = Frame(self)
+        self._frame.show_and_hide(3)
+
+    def _open_terminal_cb(self):
+        self.start_activity('org.sugar.Terminal')
+        return False
+
+    def __global_key_pressed_cb(self, grabber, key):
+        if key == 'F1':
+            self.set_zoom_level(sugar.ZOOM_MESH)
+        elif key == 'F2':
+            self.set_zoom_level(sugar.ZOOM_FRIENDS)
+        elif key == 'F3':
+            self.set_zoom_level(sugar.ZOOM_HOME)
+        elif key == 'F4':
+            self.set_zoom_level(sugar.ZOOM_ACTIVITY)
+        elif key == 'F5':
+            self._dcon_manager.decrease_brightness()
+        elif key == 'F6':
+            self._dcon_manager.increase_brightness()
+        elif key == 'F7':
+            self._dcon_manager.set_mode(DCONManager.COLOR_MODE)
+        elif key == 'F8':
+            self._dcon_manager.set_mode(DCONManager.BLACK_AND_WHITE_MODE)
+        elif key == '<shft><alt>F9':
+            self._frame.notify_key_press()
+        elif key == '<shft><alt>F10':
+            self.toggle_chat_visibility()
+        elif key == '<shft><alt>F11':
+            gobject.idle_add(self._open_terminal_cb)
+        elif key == '0xDC': # Camera key
+            pass
+        elif key == '0xE0': # Overlay key
+            self.toggle_chat_visibility()
+        elif key == '0x93': # Frame key
+            self._frame.notify_key_press()
+
+    def __global_key_released_cb(self, grabber, key):
+        if key == '<shft><alt>F9':
+            self._frame.notify_key_release()
+        elif key == '0x93':
+            self._frame.notify_key_release()
+
+    def __window_opened_cb(self, screen, window):
+        if window.get_window_type() == wnck.WINDOW_NORMAL:
+            activity_host = ActivityHost(self.get_model(), window)
+            self._hosts[activity_host.get_xid()] = activity_host
+            self.emit('activity-opened', activity_host)
+
+    def __active_window_changed_cb(self, screen):
+        window = screen.get_active_window()
+        if not window or window.get_window_type() != wnck.WINDOW_NORMAL:
+            return
+        if not self._hosts.has_key(window.get_xid()):
+            return
+
+        activity_host = self._hosts[window.get_xid()]
+        current = self._model.get_current_activity()
+        if activity_host.get_id() == current:
+            return
+
+        self._set_current_activity(activity_host)
+
+    def __window_closed_cb(self, screen, window):
+        if window.get_window_type() != wnck.WINDOW_NORMAL:
+            return
+
+        if not self._hosts.has_key(window.get_xid()):
+            return
+
+        host = self._hosts[window.get_xid()]
+        host.destroy()
+
+        self.emit('activity-closed', host)
+        del self._hosts[window.get_xid()]
+
+        if len(self._hosts) == 0:
+            self._set_current_activity(None)
+
+    def _set_current_activity(self, host):
+        if host:
+            self._model.set_current_activity(host.get_id())
+        else:
+            self._model.set_current_activity(None)
+
+        if self._current_host:
+            self._current_host.set_active(False)
+
+        self._current_host = host
+
+        if self._current_host:
+            self._current_host.set_active(True)
+
+        self.emit('activity-changed', host)
+
+    def get_model(self):
+        return self._model
+
+    def join_activity(self, bundle_id, activity_id):
+        pservice = PresenceService.get_instance()
+
+        activity = self._get_activity(activity_id)
+        if activity:
+            activity.present()
+        else:
+            activity_ps = pservice.get_activity(activity_id)
+
+            if activity_ps:
+                activity = ActivityFactory.create(bundle_id)
+                activity.join(activity_ps.object_path())
+            else:
+                logging.error('Cannot start activity.')
+
+    def start_activity(self, activity_type):
+        activity = ActivityFactory.create(activity_type)
+        activity.execute('test', [])
+        return activity
+
+    def set_zoom_level(self, level):
+        if level == sugar.ZOOM_ACTIVITY:
+            self._screen.toggle_showing_desktop(False)
+        else:
+            self._screen.toggle_showing_desktop(True)
+            self._home_window.set_zoom_level(level)
+
+    def get_current_activity(self):
+        activity_id = self._model.get_current_activity()
+        if activity_id:
+            return self._get_activity(activity_id)
+        else:
+            return None
+
+    def _get_activity(self, activity_id):
+        for host in self._hosts.values():
+            if host.get_id() == activity_id:
+                return host
+        return None
+
+    def toggle_chat_visibility(self):
+        act = self.get_current_activity()
+        if not act:
+            return
+        is_visible = self._frame.is_visible()
+        if act.is_chat_visible():
+            frame_was_visible = act.chat_hide()
+            if not frame_was_visible:
+                self._frame.do_slide_out()
+        else:
+            if not is_visible:
+                self._frame.do_slide_in()
+            act.chat_show(is_visible)
diff --git a/shell/view/dconmanager.py b/shell/view/dconmanager.py
index 2cf40b5..2db626a 100644
--- a/shell/view/dconmanager.py
+++ b/shell/view/dconmanager.py
@@ -21,23 +21,23 @@ DCON_MANAGER_SERVICE = 'org.laptop.DCONManager'
 DCON_MANAGER_OBJECT_PATH = '/org/laptop/DCONManager'
 
 class DCONManager(object):
-	COLOR_MODE = 0
-	BLACK_AND_WHITE_MODE = 1
+    COLOR_MODE = 0
+    BLACK_AND_WHITE_MODE = 1
 
-	def __init__(self):
-		bus = dbus.SystemBus()
-		proxy = bus.get_object(DCON_MANAGER_SERVICE, DCON_MANAGER_OBJECT_PATH)
-		self._service = dbus.Interface(proxy, DCON_MANAGER_INTERFACE)
+    def __init__(self):
+        bus = dbus.SystemBus()
+        proxy = bus.get_object(DCON_MANAGER_SERVICE, DCON_MANAGER_OBJECT_PATH)
+        self._service = dbus.Interface(proxy, DCON_MANAGER_INTERFACE)
 
-	def set_mode(self, mode):
-		self._service.set_mode(mode)
+    def set_mode(self, mode):
+        self._service.set_mode(mode)
 
-	def increase_brightness(self):
-		level = self._service.get_backlight_level()
-		if level >= 0:
-			self._service.set_backlight_level(level + 1)
+    def increase_brightness(self):
+        level = self._service.get_backlight_level()
+        if level >= 0:
+            self._service.set_backlight_level(level + 1)
 
-	def decrease_brightness(self):
-		level = self._service.get_backlight_level()
-		if level >= 0:
-			self._service.set_backlight_level(level - 1)
+    def decrease_brightness(self):
+        level = self._service.get_backlight_level()
+        if level >= 0:
+            self._service.set_backlight_level(level - 1)
diff --git a/shell/view/frame/ActivitiesBox.py b/shell/view/frame/ActivitiesBox.py
index 2e3a75a..aa96585 100644
--- a/shell/view/frame/ActivitiesBox.py
+++ b/shell/view/frame/ActivitiesBox.py
@@ -22,80 +22,80 @@ from sugar.presence import PresenceService
 from sugar.graphics import style
 
 class ActivityItem(CanvasIcon):
-	def __init__(self, activity):
-		icon_name = activity.get_icon()
-		CanvasIcon.__init__(self, icon_name=icon_name)
-		style.apply_stylesheet(self, 'frame.ActivityIcon')
-		self._activity = activity
+    def __init__(self, activity):
+        icon_name = activity.get_icon()
+        CanvasIcon.__init__(self, icon_name=icon_name)
+        style.apply_stylesheet(self, 'frame.ActivityIcon')
+        self._activity = activity
 
-	def get_bundle_id(self):
-		return self._activity.get_service_name()
+    def get_bundle_id(self):
+        return self._activity.get_service_name()
 
 class InviteItem(CanvasIcon):
-	def __init__(self, activity, invite):
-		CanvasIcon.__init__(self, icon_name=activity.get_icon())
+    def __init__(self, activity, invite):
+        CanvasIcon.__init__(self, icon_name=activity.get_icon())
 
-		style.apply_stylesheet(self, 'frame.ActivityIcon')
-		self.props.color = activity.get_color()
+        style.apply_stylesheet(self, 'frame.ActivityIcon')
+        self.props.color = activity.get_color()
 
-		self._invite = invite
+        self._invite = invite
 
-	def get_activity_id(self):
-		return self._invite.get_activity_id()
+    def get_activity_id(self):
+        return self._invite.get_activity_id()
 
-	def get_bundle_id(self):
-		return self._invite.get_bundle_id()
+    def get_bundle_id(self):
+        return self._invite.get_bundle_id()
 
-	def get_invite(self):
-		return self._invite
+    def get_invite(self):
+        return self._invite
 
 class ActivitiesBox(hippo.CanvasBox):
-	def __init__(self, shell):
-		hippo.CanvasBox.__init__(self, orientation=hippo.ORIENTATION_HORIZONTAL)
-
-		self._shell = shell
-		self._shell_model = self._shell.get_model() 
-		self._invite_to_item = {}
-		self._invites = self._shell_model.get_invites()
-
-		for bundle in self._shell_model.get_bundle_registry():
-			if bundle.get_show_launcher():
-				self.add_activity(bundle)
-
-		for invite in self._invites:
-			self.add_invite(invite)
-		self._invites.connect('invite-added', self._invite_added_cb)
-		self._invites.connect('invite-removed', self._invite_removed_cb)
-
-	def _activity_clicked_cb(self, icon):
-		self._shell.start_activity(icon.get_bundle_id())
-
-	def _invite_clicked_cb(self, icon):
-		self._invites.remove_invite(icon.get_invite())
-		self._shell.join_activity(icon.get_bundle_id(),
-								  icon.get_activity_id())
-	
-	def _invite_added_cb(self, invites, invite):
-		self.add_invite(invite)
-
-	def _invite_removed_cb(self, invites, invite):
-		self.remove_invite(invite)
-
-	def add_activity(self, activity):
-		item = ActivityItem(activity)
-		item.connect('activated', self._activity_clicked_cb)
-		self.append(item, 0)
-
-	def add_invite(self, invite):
-		mesh = self._shell_model.get_mesh()
-		activity = mesh.get_activity(invite.get_activity_id())
-		if activity:
-			item = InviteItem(activity, invite)
-			item.connect('activated', self._invite_clicked_cb)
-			self.append(item, 0)
-
-			self._invite_to_item[invite] = item
-
-	def remove_invite(self, invite):
-		self.remove(self._invite_to_item[invite])
-		del self._invite_to_item[invite]
+    def __init__(self, shell):
+        hippo.CanvasBox.__init__(self, orientation=hippo.ORIENTATION_HORIZONTAL)
+
+        self._shell = shell
+        self._shell_model = self._shell.get_model() 
+        self._invite_to_item = {}
+        self._invites = self._shell_model.get_invites()
+
+        for bundle in self._shell_model.get_bundle_registry():
+            if bundle.get_show_launcher():
+                self.add_activity(bundle)
+
+        for invite in self._invites:
+            self.add_invite(invite)
+        self._invites.connect('invite-added', self._invite_added_cb)
+        self._invites.connect('invite-removed', self._invite_removed_cb)
+
+    def _activity_clicked_cb(self, icon):
+        self._shell.start_activity(icon.get_bundle_id())
+
+    def _invite_clicked_cb(self, icon):
+        self._invites.remove_invite(icon.get_invite())
+        self._shell.join_activity(icon.get_bundle_id(),
+                                  icon.get_activity_id())
+    
+    def _invite_added_cb(self, invites, invite):
+        self.add_invite(invite)
+
+    def _invite_removed_cb(self, invites, invite):
+        self.remove_invite(invite)
+
+    def add_activity(self, activity):
+        item = ActivityItem(activity)
+        item.connect('activated', self._activity_clicked_cb)
+        self.append(item, 0)
+
+    def add_invite(self, invite):
+        mesh = self._shell_model.get_mesh()
+        activity = mesh.get_activity(invite.get_activity_id())
+        if activity:
+            item = InviteItem(activity, invite)
+            item.connect('activated', self._invite_clicked_cb)
+            self.append(item, 0)
+
+            self._invite_to_item[invite] = item
+
+    def remove_invite(self, invite):
+        self.remove(self._invite_to_item[invite])
+        del self._invite_to_item[invite]
diff --git a/shell/view/frame/ClipboardBox.py b/shell/view/frame/ClipboardBox.py
index 849c7e0..82dccb6 100644
--- a/shell/view/frame/ClipboardBox.py
+++ b/shell/view/frame/ClipboardBox.py
@@ -7,36 +7,36 @@ from view.ClipboardIcon import ClipboardIcon
 from sugar.clipboard import ClipboardService
 
 class ClipboardBox(hippo.CanvasBox):
-	
-	def __init__(self, frame, menu_shell):
-		hippo.CanvasBox.__init__(self)
-		self._frame = frame
-		self._menu_shell = menu_shell
-		self._icons = {}
-		
-		cb_service = ClipboardService.get_instance()
-		cb_service.connect('object-added', self._object_added_cb)
-		cb_service.connect('object-deleted', self._object_deleted_cb)
-		cb_service.connect('object-state-changed', self._object_state_changed_cb)
+    
+    def __init__(self, frame, menu_shell):
+        hippo.CanvasBox.__init__(self)
+        self._frame = frame
+        self._menu_shell = menu_shell
+        self._icons = {}
+        
+        cb_service = ClipboardService.get_instance()
+        cb_service.connect('object-added', self._object_added_cb)
+        cb_service.connect('object-deleted', self._object_deleted_cb)
+        cb_service.connect('object-state-changed', self._object_state_changed_cb)
 
-	def _object_added_cb(self, cb_service, name, mimeType, fileName):
-		icon = ClipboardIcon(self._menu_shell, name, fileName)
-		style.apply_stylesheet(icon, 'frame.BuddyIcon')
-		self.append(icon)
-		self._icons[fileName] = icon
-		
-		if not self._frame.is_visible():
-			self._frame.show_and_hide(0.1)
-		
-		logging.debug('ClipboardBox: ' + fileName + ' was added.')
+    def _object_added_cb(self, cb_service, name, mimeType, fileName):
+        icon = ClipboardIcon(self._menu_shell, name, fileName)
+        style.apply_stylesheet(icon, 'frame.BuddyIcon')
+        self.append(icon)
+        self._icons[fileName] = icon
+        
+        if not self._frame.is_visible():
+            self._frame.show_and_hide(0.1)
+        
+        logging.debug('ClipboardBox: ' + fileName + ' was added.')
 
-	def _object_deleted_cb(self, cb_service, fileName):
-		icon = self._icons[fileName]
-		self.remove(icon)
-		del self._icons[fileName]
-		logging.debug('ClipboardBox: ' + fileName + ' was deleted.')
+    def _object_deleted_cb(self, cb_service, fileName):
+        icon = self._icons[fileName]
+        self.remove(icon)
+        del self._icons[fileName]
+        logging.debug('ClipboardBox: ' + fileName + ' was deleted.')
 
-	def _object_state_changed_cb(self, cb_service, fileName, percent):
-		icon = self._icons[fileName]
-		icon.set_percent(percent)
-		logging.debug('ClipboardBox: ' + fileName + ' state was changed.')
+    def _object_state_changed_cb(self, cb_service, fileName, percent):
+        icon = self._icons[fileName]
+        icon.set_percent(percent)
+        logging.debug('ClipboardBox: ' + fileName + ' state was changed.')
diff --git a/shell/view/frame/Frame.py b/shell/view/frame/Frame.py
index 37f28cb..c865219 100644
--- a/shell/view/frame/Frame.py
+++ b/shell/view/frame/Frame.py
@@ -32,268 +32,268 @@ from sugar.graphics.grid import Grid
 from sugar.graphics.menushell import MenuShell
 
 class EventFrame(gobject.GObject):
-	__gsignals__ = {
-		'enter-edge':    (gobject.SIGNAL_RUN_FIRST,
-				          gobject.TYPE_NONE, ([])),
-		'enter-corner':  (gobject.SIGNAL_RUN_FIRST,
-				          gobject.TYPE_NONE, ([])),
-		'leave':		 (gobject.SIGNAL_RUN_FIRST,
-				          gobject.TYPE_NONE, ([]))
-	}
-
-	HOVER_NONE = 0
-	HOVER_CORNER = 1
-	HOVER_EDGE = 2
-
-	def __init__(self):
-		gobject.GObject.__init__(self)
-
-		self._windows = []
-		self._hover = EventFrame.HOVER_NONE
-		self._active = False
-
-		invisible = self._create_invisible(0, 0, gtk.gdk.screen_width(), 1)
-		self._windows.append(invisible)
-
-		invisible = self._create_invisible(0, 0, 1, gtk.gdk.screen_height())
-		self._windows.append(invisible)
-
-		invisible = self._create_invisible(gtk.gdk.screen_width() - 1, 0,
-										   gtk.gdk.screen_width(),
-										   gtk.gdk.screen_height())
-		self._windows.append(invisible)
-
-		invisible = self._create_invisible(0, gtk.gdk.screen_height() - 1,
-										   gtk.gdk.screen_width(),
-										   gtk.gdk.screen_height())
-		self._windows.append(invisible)
-
-		screen = wnck.screen_get_default()
-		screen.connect('active-window-changed',
-					   self._active_window_changed_cb)
-
-	def _create_invisible(self, x, y, width, height):
-		invisible = gtk.Invisible()
-		invisible.connect('motion-notify-event', self._motion_notify_cb)
-		invisible.connect('enter-notify-event', self._enter_notify_cb)
-		invisible.connect('leave-notify-event', self._leave_notify_cb)
-
-		invisible.realize()
-		invisible.window.set_events(gtk.gdk.POINTER_MOTION_MASK |
-									gtk.gdk.ENTER_NOTIFY_MASK |
-									gtk.gdk.LEAVE_NOTIFY_MASK)
-		invisible.window.move_resize(x, y, width, height)
-
-		return invisible
-
-	def _enter_notify_cb(self, widget, event):
-		self._notify_enter(event.x, event.y)
-
-	def _motion_notify_cb(self, widget, event):
-		self._notify_enter(event.x, event.y)
-
-	def _notify_enter(self, x, y):
-		screen_w = gtk.gdk.screen_width()
-		screen_h = gtk.gdk.screen_height()
-
-		if (x == 0 and y == 0) or \
-		   (x == 0 and y == screen_h - 1) or \
-		   (x == screen_w - 1 and y == 0) or \
-		   (x == screen_w - 1 and y == screen_h - 1):
-			if self._hover != EventFrame.HOVER_CORNER:
-				self._hover = EventFrame.HOVER_CORNER
-				self.emit('enter-corner')
-		else:
-			if self._hover != EventFrame.HOVER_EDGE:
-				self._hover = EventFrame.HOVER_EDGE
-				self.emit('enter-edge')
-
-	def _leave_notify_cb(self, widget, event):
-		self._hover = EventFrame.HOVER_NONE
-		if self._active:
-			self.emit('leave')
-
-	def show(self):
-		self._active = True
-		for window in self._windows:
-			window.show()
-
-	def hide(self):
-		self._active = False
-		for window in self._windows:
-			window.hide()
-
-	def _active_window_changed_cb(self, screen):
-		for window in self._windows:
-			window.window.raise_()
+    __gsignals__ = {
+        'enter-edge':    (gobject.SIGNAL_RUN_FIRST,
+                          gobject.TYPE_NONE, ([])),
+        'enter-corner':  (gobject.SIGNAL_RUN_FIRST,
+                          gobject.TYPE_NONE, ([])),
+        'leave':         (gobject.SIGNAL_RUN_FIRST,
+                          gobject.TYPE_NONE, ([]))
+    }
+
+    HOVER_NONE = 0
+    HOVER_CORNER = 1
+    HOVER_EDGE = 2
+
+    def __init__(self):
+        gobject.GObject.__init__(self)
+
+        self._windows = []
+        self._hover = EventFrame.HOVER_NONE
+        self._active = False
+
+        invisible = self._create_invisible(0, 0, gtk.gdk.screen_width(), 1)
+        self._windows.append(invisible)
+
+        invisible = self._create_invisible(0, 0, 1, gtk.gdk.screen_height())
+        self._windows.append(invisible)
+
+        invisible = self._create_invisible(gtk.gdk.screen_width() - 1, 0,
+                                           gtk.gdk.screen_width(),
+                                           gtk.gdk.screen_height())
+        self._windows.append(invisible)
+
+        invisible = self._create_invisible(0, gtk.gdk.screen_height() - 1,
+                                           gtk.gdk.screen_width(),
+                                           gtk.gdk.screen_height())
+        self._windows.append(invisible)
+
+        screen = wnck.screen_get_default()
+        screen.connect('active-window-changed',
+                       self._active_window_changed_cb)
+
+    def _create_invisible(self, x, y, width, height):
+        invisible = gtk.Invisible()
+        invisible.connect('motion-notify-event', self._motion_notify_cb)
+        invisible.connect('enter-notify-event', self._enter_notify_cb)
+        invisible.connect('leave-notify-event', self._leave_notify_cb)
+
+        invisible.realize()
+        invisible.window.set_events(gtk.gdk.POINTER_MOTION_MASK |
+                                    gtk.gdk.ENTER_NOTIFY_MASK |
+                                    gtk.gdk.LEAVE_NOTIFY_MASK)
+        invisible.window.move_resize(x, y, width, height)
+
+        return invisible
+
+    def _enter_notify_cb(self, widget, event):
+        self._notify_enter(event.x, event.y)
+
+    def _motion_notify_cb(self, widget, event):
+        self._notify_enter(event.x, event.y)
+
+    def _notify_enter(self, x, y):
+        screen_w = gtk.gdk.screen_width()
+        screen_h = gtk.gdk.screen_height()
+
+        if (x == 0 and y == 0) or \
+           (x == 0 and y == screen_h - 1) or \
+           (x == screen_w - 1 and y == 0) or \
+           (x == screen_w - 1 and y == screen_h - 1):
+            if self._hover != EventFrame.HOVER_CORNER:
+                self._hover = EventFrame.HOVER_CORNER
+                self.emit('enter-corner')
+        else:
+            if self._hover != EventFrame.HOVER_EDGE:
+                self._hover = EventFrame.HOVER_EDGE
+                self.emit('enter-edge')
+
+    def _leave_notify_cb(self, widget, event):
+        self._hover = EventFrame.HOVER_NONE
+        if self._active:
+            self.emit('leave')
+
+    def show(self):
+        self._active = True
+        for window in self._windows:
+            window.show()
+
+    def hide(self):
+        self._active = False
+        for window in self._windows:
+            window.hide()
+
+    def _active_window_changed_cb(self, screen):
+        for window in self._windows:
+            window.window.raise_()
 
 class Frame:
-	INACTIVE = 0
-	TEMPORARY = 1
-	STICKY = 2
-	HIDE_ON_LEAVE = 3
-	AUTOMATIC = 4
+    INACTIVE = 0
+    TEMPORARY = 1
+    STICKY = 2
+    HIDE_ON_LEAVE = 3
+    AUTOMATIC = 4
 
-	def __init__(self, shell):
-		self._windows = []
-		self._active_menus = 0
-		self._shell = shell
-		self._mode = Frame.INACTIVE
+    def __init__(self, shell):
+        self._windows = []
+        self._active_menus = 0
+        self._shell = shell
+        self._mode = Frame.INACTIVE
 
-		self._timeline = Timeline(self)
-		self._timeline.add_tag('slide_in', 6, 12)
-		self._timeline.add_tag('before_slide_out', 36, 36)
-		self._timeline.add_tag('slide_out', 37, 42)
+        self._timeline = Timeline(self)
+        self._timeline.add_tag('slide_in', 6, 12)
+        self._timeline.add_tag('before_slide_out', 36, 36)
+        self._timeline.add_tag('slide_out', 37, 42)
 
-		self._event_frame = EventFrame()
-		self._event_frame.connect('enter-edge', self._enter_edge_cb)
-		self._event_frame.connect('enter-corner', self._enter_corner_cb)
-		self._event_frame.connect('leave', self._event_frame_leave_cb)
-		self._event_frame.show()
+        self._event_frame = EventFrame()
+        self._event_frame.connect('enter-edge', self._enter_edge_cb)
+        self._event_frame.connect('enter-corner', self._enter_corner_cb)
+        self._event_frame.connect('leave', self._event_frame_leave_cb)
+        self._event_frame.show()
 
-		grid = Grid()
+        grid = Grid()
 
-		# Top panel
-		[menu_shell, root] = self._create_panel(grid, 0, 0, 16, 1)
-		menu_shell.set_position(MenuShell.BOTTOM)
+        # Top panel
+        [menu_shell, root] = self._create_panel(grid, 0, 0, 16, 1)
+        menu_shell.set_position(MenuShell.BOTTOM)
 
-		box = ZoomBox(self._shell, menu_shell)
+        box = ZoomBox(self._shell, menu_shell)
 
-		[x, y] = grid.point(1, 0)
-		root.append(box, hippo.PACK_FIXED)
-		root.move(box, x, y)
+        [x, y] = grid.point(1, 0)
+        root.append(box, hippo.PACK_FIXED)
+        root.move(box, x, y)
 
-		tray = NotificationTray()
-		tray_box = hippo.CanvasBox(box_width=grid.dimension(1),
-								   box_height=grid.dimension(1),
-								   xalign=hippo.ALIGNMENT_END)
+        tray = NotificationTray()
+        tray_box = hippo.CanvasBox(box_width=grid.dimension(1),
+                                   box_height=grid.dimension(1),
+                                   xalign=hippo.ALIGNMENT_END)
 
-		tray_widget = hippo.CanvasWidget()
-		tray_widget.props.widget = tray
-		tray_box.append(tray_widget, gtk.EXPAND)
+        tray_widget = hippo.CanvasWidget()
+        tray_widget.props.widget = tray
+        tray_box.append(tray_widget, gtk.EXPAND)
 
-		[x, y] = grid.point(13, 0)
-		root.append(tray_box, hippo.PACK_FIXED)
-		root.move(tray_box, x, y)
+        [x, y] = grid.point(13, 0)
+        root.append(tray_box, hippo.PACK_FIXED)
+        root.move(tray_box, x, y)
 
-		box = OverlayBox(self._shell)
+        box = OverlayBox(self._shell)
 
-		[x, y] = grid.point(14, 0)
-		root.append(box, hippo.PACK_FIXED)
-		root.move(box, x, y)
+        [x, y] = grid.point(14, 0)
+        root.append(box, hippo.PACK_FIXED)
+        root.move(box, x, y)
 
-		shutdown_icon = ShutdownIcon(menu_shell)
+        shutdown_icon = ShutdownIcon(menu_shell)
 
-		[x, y] = grid.point(12, 0)
-		root.append(shutdown_icon, hippo.PACK_FIXED)
-		root.move(shutdown_icon, x, y)
+        [x, y] = grid.point(12, 0)
+        root.append(shutdown_icon, hippo.PACK_FIXED)
+        root.move(shutdown_icon, x, y)
 
-		# Bottom panel
-		[menu_shell, root] = self._create_panel(grid, 0, 11, 16, 1)
-		menu_shell.set_position(MenuShell.TOP)
+        # Bottom panel
+        [menu_shell, root] = self._create_panel(grid, 0, 11, 16, 1)
+        menu_shell.set_position(MenuShell.TOP)
 
-		box = ActivitiesBox(self._shell)
-		root.append(box, hippo.PACK_FIXED)
+        box = ActivitiesBox(self._shell)
+        root.append(box, hippo.PACK_FIXED)
 
-		[x, y] = grid.point(1, 0)
-		root.move(box, x, y)
+        [x, y] = grid.point(1, 0)
+        root.move(box, x, y)
 
-		# Right panel
-		[menu_shell, root] = self._create_panel(grid, 15, 1, 1, 10)
-		menu_shell.set_position(MenuShell.LEFT)
+        # Right panel
+        [menu_shell, root] = self._create_panel(grid, 15, 1, 1, 10)
+        menu_shell.set_position(MenuShell.LEFT)
 
-		box = FriendsBox(self._shell, menu_shell)
-		root.append(box)
+        box = FriendsBox(self._shell, menu_shell)
+        root.append(box)
 
-		# Left panel
-		[menu_shell, root] = self._create_panel(grid, 0, 1, 1, 10)
+        # Left panel
+        [menu_shell, root] = self._create_panel(grid, 0, 1, 1, 10)
 
-		box = ClipboardBox(self, menu_shell)
-		root.append(box)
+        box = ClipboardBox(self, menu_shell)
+        root.append(box)
 
-	def _create_panel(self, grid, x, y, width, height):
-		panel = PanelWindow()
+    def _create_panel(self, grid, x, y, width, height):
+        panel = PanelWindow()
 
-		panel.connect('enter-notify-event', self._enter_notify_cb)
-		panel.connect('leave-notify-event', self._leave_notify_cb)
+        panel.connect('enter-notify-event', self._enter_notify_cb)
+        panel.connect('leave-notify-event', self._leave_notify_cb)
 
-		menu_shell = panel.get_menu_shell()
-		menu_shell.connect('activated', self._menu_shell_activated_cb)
-		menu_shell.connect('deactivated', self._menu_shell_deactivated_cb)
+        menu_shell = panel.get_menu_shell()
+        menu_shell.connect('activated', self._menu_shell_activated_cb)
+        menu_shell.connect('deactivated', self._menu_shell_deactivated_cb)
 
-		[x, y, width, height] = grid.rectangle(x, y, width, height)
+        [x, y, width, height] = grid.rectangle(x, y, width, height)
 
-		panel.move(x, y)
-		panel.resize(width, height)
+        panel.move(x, y)
+        panel.resize(width, height)
 
-		self._windows.append(panel)
+        self._windows.append(panel)
 
-		return [panel.get_menu_shell(), panel.get_root()]
+        return [panel.get_menu_shell(), panel.get_root()]
 
-	def _menu_shell_activated_cb(self, menu_shell):
-		self._active_menus += 1
-		self._timeline.goto('slide_in', True)
+    def _menu_shell_activated_cb(self, menu_shell):
+        self._active_menus += 1
+        self._timeline.goto('slide_in', True)
 
-	def _menu_shell_deactivated_cb(self, menu_shell):
-		self._active_menus -= 1
-		if self._mode != Frame.STICKY:
-			self._timeline.play('before_slide_out', 'slide_out')
+    def _menu_shell_deactivated_cb(self, menu_shell):
+        self._active_menus -= 1
+        if self._mode != Frame.STICKY:
+            self._timeline.play('before_slide_out', 'slide_out')
 
-	def _enter_notify_cb(self, window, event):
-		self._timeline.goto('slide_in', True)
+    def _enter_notify_cb(self, window, event):
+        self._timeline.goto('slide_in', True)
 
-	def _leave_notify_cb(self, window, event):
-		# FIXME for some reason every click cause also a leave-notify
-		if event.state == gtk.gdk.BUTTON1_MASK:
-			return
+    def _leave_notify_cb(self, window, event):
+        # FIXME for some reason every click cause also a leave-notify
+        if event.state == gtk.gdk.BUTTON1_MASK:
+            return
 
-		if self._active_menus == 0 and \
-		   (self._mode == Frame.HIDE_ON_LEAVE or \
-		    self._mode == Frame.AUTOMATIC):
-			self._timeline.play('before_slide_out', 'slide_out')
+        if self._active_menus == 0 and \
+           (self._mode == Frame.HIDE_ON_LEAVE or \
+            self._mode == Frame.AUTOMATIC):
+            self._timeline.play('before_slide_out', 'slide_out')
 
-	def _enter_edge_cb(self, event_frame):
-		self._mode = Frame.HIDE_ON_LEAVE
-		self._timeline.play(None, 'slide_in')
+    def _enter_edge_cb(self, event_frame):
+        self._mode = Frame.HIDE_ON_LEAVE
+        self._timeline.play(None, 'slide_in')
 
-	def _enter_corner_cb(self, event_frame):
-		self._mode = Frame.HIDE_ON_LEAVE
-		self._timeline.play('slide_in', 'slide_in')
+    def _enter_corner_cb(self, event_frame):
+        self._mode = Frame.HIDE_ON_LEAVE
+        self._timeline.play('slide_in', 'slide_in')
 
-	def _event_frame_leave_cb(self, event_frame):
-		if self._mode != Frame.STICKY:
-			self._timeline.goto('slide_out', True)
+    def _event_frame_leave_cb(self, event_frame):
+        if self._mode != Frame.STICKY:
+            self._timeline.goto('slide_out', True)
 
-	def show_and_hide(self, seconds):
-		self._mode = Frame.AUTOMATIC
-		self._timeline.play()
+    def show_and_hide(self, seconds):
+        self._mode = Frame.AUTOMATIC
+        self._timeline.play()
 
-	def notify_key_press(self):
-		if self._timeline.on_tag('slide_in'):
-			self._timeline.play('before_slide_out', 'slide_out')
-		elif self._timeline.on_tag('before_slide_out'):
-			self._mode = Frame.TEMPORARY
-		else:
-			self._mode = Frame.STICKY
-			self._timeline.play('slide_in', 'slide_in')
+    def notify_key_press(self):
+        if self._timeline.on_tag('slide_in'):
+            self._timeline.play('before_slide_out', 'slide_out')
+        elif self._timeline.on_tag('before_slide_out'):
+            self._mode = Frame.TEMPORARY
+        else:
+            self._mode = Frame.STICKY
+            self._timeline.play('slide_in', 'slide_in')
 
-	def notify_key_release(self):
-		if self._mode == Frame.TEMPORARY:
-			self._timeline.play('before_slide_out', 'slide_out')
+    def notify_key_release(self):
+        if self._mode == Frame.TEMPORARY:
+            self._timeline.play('before_slide_out', 'slide_out')
 
-	def do_slide_in(self, current=0, n_frames=0):
-		if not self._windows[0].props.visible:
-			for panel in self._windows:
-				panel.show()
-			self._event_frame.hide()
+    def do_slide_in(self, current=0, n_frames=0):
+        if not self._windows[0].props.visible:
+            for panel in self._windows:
+                panel.show()
+            self._event_frame.hide()
 
-	def do_slide_out(self, current=0, n_frames=0):
-		if self._windows[0].props.visible:
-			for panel in self._windows:
-				panel.hide()
-			self._event_frame.show()
+    def do_slide_out(self, current=0, n_frames=0):
+        if self._windows[0].props.visible:
+            for panel in self._windows:
+                panel.hide()
+            self._event_frame.show()
 
-	def is_visible(self):
-		if self._windows[0].props.visible:
-			return True
-		return False
+    def is_visible(self):
+        if self._windows[0].props.visible:
+            return True
+        return False
diff --git a/shell/view/frame/FriendsBox.py b/shell/view/frame/FriendsBox.py
index 14f1290..cdc07ad 100644
--- a/shell/view/frame/FriendsBox.py
+++ b/shell/view/frame/FriendsBox.py
@@ -24,85 +24,85 @@ from view.BuddyIcon import BuddyIcon
 from model.BuddyModel import BuddyModel
 
 class FriendsBox(hippo.CanvasBox):
-	def __init__(self, shell, menu_shell):
-		hippo.CanvasBox.__init__(self)
-		self._shell = shell
-		self._menu_shell = menu_shell
-		self._activity_ps = None
-		self._joined_hid = -1
-		self._left_hid = -1
-		self._buddies = {}
-
-		self._pservice = PresenceService.get_instance()
-		self._pservice.connect('activity-appeared',
-							   self.__activity_appeared_cb)
-
-		# Add initial activities the PS knows about
-		for activity in self._pservice.get_activities():
-			self.__activity_appeared_cb(self._pservice, activity)
-
-		shell.connect('activity-changed', self.__activity_changed_cb)
-
-	def add_buddy(self, buddy):
-		if self._buddies.has_key(buddy.get_name()):
-			return
-
-		model = BuddyModel(buddy=buddy)
-		icon = BuddyIcon(self._shell, self._menu_shell, model)
-		style.apply_stylesheet(icon, 'frame.BuddyIcon')
-		self.append(icon)
-
-		self._buddies[buddy.get_name()] = icon
-
-	def remove_buddy(self, buddy):
-		if not self._buddies.has_key(buddy.get_name()):
-			return
-
-		self.remove(self._buddies[buddy.get_name()])
-
-	def clear(self):
-		for item in self.get_children():
-			self.remove(item)
-		self._buddies = {}
-
-	def __activity_appeared_cb(self, pservice, activity_ps):
-		activity = self._shell.get_current_activity()
-		if activity and activity_ps.get_id() == activity.get_id():
-			self._set_activity_ps(activity_ps)
-
-	def _set_activity_ps(self, activity_ps):
-		if self._activity_ps == activity_ps:
-			return
-
-		if self._joined_hid > 0:
-			self._activity_ps.disconnect(self._joined_hid)
-			self._joined_hid = -1
-		if self._left_hid > 0:
-			self._activity_ps.disconnect(self._left_hid)
-			self._left_hid = -1
-
-		self._activity_ps = activity_ps
-
-		self.clear()
-
-		if activity_ps != None:
-			for buddy in activity_ps.get_joined_buddies():
-				self.add_buddy(buddy)
-
-			self._joined_hid = activity_ps.connect(
-							'buddy-joined', self.__buddy_joined_cb)
-			self._left_hid = activity_ps.connect(
-							'buddy-left', self.__buddy_left_cb)
-
-	def __activity_changed_cb(self, group, activity):
-		if activity:
-			ps = self._pservice.get_activity(activity.get_id())
-			self._set_activity_ps(ps)
-		else:
-			self._set_activity_ps(None)
-
-	def __buddy_joined_cb(self, activity, buddy):
-		self.add_buddy(buddy)
-
-	def __buddy_left_cb(self, activity, buddy):
-		self.remove_buddy(buddy)
+    def __init__(self, shell, menu_shell):
+        hippo.CanvasBox.__init__(self)
+        self._shell = shell
+        self._menu_shell = menu_shell
+        self._activity_ps = None
+        self._joined_hid = -1
+        self._left_hid = -1
+        self._buddies = {}
+
+        self._pservice = PresenceService.get_instance()
+        self._pservice.connect('activity-appeared',
+                               self.__activity_appeared_cb)
+
+        # Add initial activities the PS knows about
+        for activity in self._pservice.get_activities():
+            self.__activity_appeared_cb(self._pservice, activity)
+
+        shell.connect('activity-changed', self.__activity_changed_cb)
+
+    def add_buddy(self, buddy):
+        if self._buddies.has_key(buddy.get_name()):
+            return
+
+        model = BuddyModel(buddy=buddy)
+        icon = BuddyIcon(self._shell, self._menu_shell, model)
+        style.apply_stylesheet(icon, 'frame.BuddyIcon')
+        self.append(icon)
+
+        self._buddies[buddy.get_name()] = icon
+
+    def remove_buddy(self, buddy):
+        if not self._buddies.has_key(buddy.get_name()):
+            return
+
+        self.remove(self._buddies[buddy.get_name()])
+
+    def clear(self):
+        for item in self.get_children():
+            self.remove(item)
+        self._buddies = {}
+
+    def __activity_appeared_cb(self, pservice, activity_ps):
+        activity = self._shell.get_current_activity()
+        if activity and activity_ps.get_id() == activity.get_id():
+            self._set_activity_ps(activity_ps)
+
+    def _set_activity_ps(self, activity_ps):
+        if self._activity_ps == activity_ps:
+            return
+
+        if self._joined_hid > 0:
+            self._activity_ps.disconnect(self._joined_hid)
+            self._joined_hid = -1
+        if self._left_hid > 0:
+            self._activity_ps.disconnect(self._left_hid)
+            self._left_hid = -1
+
+        self._activity_ps = activity_ps
+
+        self.clear()
+
+        if activity_ps != None:
+            for buddy in activity_ps.get_joined_buddies():
+                self.add_buddy(buddy)
+
+            self._joined_hid = activity_ps.connect(
+                            'buddy-joined', self.__buddy_joined_cb)
+            self._left_hid = activity_ps.connect(
+                            'buddy-left', self.__buddy_left_cb)
+
+    def __activity_changed_cb(self, group, activity):
+        if activity:
+            ps = self._pservice.get_activity(activity.get_id())
+            self._set_activity_ps(ps)
+        else:
+            self._set_activity_ps(None)
+
+    def __buddy_joined_cb(self, activity, buddy):
+        self.add_buddy(buddy)
+
+    def __buddy_left_cb(self, activity, buddy):
+        self.remove_buddy(buddy)
diff --git a/shell/view/frame/PanelWindow.py b/shell/view/frame/PanelWindow.py
index 14e72b1..8fd8145 100644
--- a/shell/view/frame/PanelWindow.py
+++ b/shell/view/frame/PanelWindow.py
@@ -20,28 +20,28 @@ import hippo
 from sugar.graphics.menushell import MenuShell
 
 class PanelWindow(gtk.Window):
-	def __init__(self):
-		gtk.Window.__init__(self)
+    def __init__(self):
+        gtk.Window.__init__(self)
 
-		self.set_decorated(False)
-		self.connect('realize', self._realize_cb)
+        self.set_decorated(False)
+        self.connect('realize', self._realize_cb)
 
-		canvas = hippo.Canvas()
+        canvas = hippo.Canvas()
 
-		self._bg = hippo.CanvasBox(background_color=0x414141ff)
-		canvas.set_root(self._bg)
+        self._bg = hippo.CanvasBox(background_color=0x414141ff)
+        canvas.set_root(self._bg)
 
-		self.add(canvas)
-		canvas.show()
+        self.add(canvas)
+        canvas.show()
 
-		self._menu_shell = MenuShell(canvas)
+        self._menu_shell = MenuShell(canvas)
 
-	def get_menu_shell(self):
-		return self._menu_shell
+    def get_menu_shell(self):
+        return self._menu_shell
 
-	def get_root(self):
-		return self._bg
+    def get_root(self):
+        return self._bg
 
-	def _realize_cb(self, widget):
-		self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
-		self.window.set_accept_focus(False)
+    def _realize_cb(self, widget):
+        self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
+        self.window.set_accept_focus(False)
diff --git a/shell/view/frame/ZoomBox.py b/shell/view/frame/ZoomBox.py
index 45c76cd..ed7e0a1 100644
--- a/shell/view/frame/ZoomBox.py
+++ b/shell/view/frame/ZoomBox.py
@@ -23,98 +23,98 @@ from sugar.graphics import style
 import sugar
 
 class ActivityMenu(Menu):
-	ACTION_SHARE = 1
-	ACTION_CLOSE = 2
+    ACTION_SHARE = 1
+    ACTION_CLOSE = 2
 
-	def __init__(self, activity_host):
-		Menu.__init__(self, activity_host.get_title())
+    def __init__(self, activity_host):
+        Menu.__init__(self, activity_host.get_title())
 
-		if not activity_host.get_shared():
-			self._add_mesh_action()
+        if not activity_host.get_shared():
+            self._add_mesh_action()
 
-		self._add_close_action()
+        self._add_close_action()
 
-	def _add_mesh_action(self):
-		icon = CanvasIcon(icon_name='stock-share-mesh')
-		self.add_action(icon, ActivityMenu.ACTION_SHARE) 
+    def _add_mesh_action(self):
+        icon = CanvasIcon(icon_name='stock-share-mesh')
+        self.add_action(icon, ActivityMenu.ACTION_SHARE) 
 
-	def _add_close_action(self):
-		icon = CanvasIcon(icon_name='stock-close')
-		self.add_action(icon, ActivityMenu.ACTION_CLOSE) 
+    def _add_close_action(self):
+        icon = CanvasIcon(icon_name='stock-close')
+        self.add_action(icon, ActivityMenu.ACTION_CLOSE) 
 
 class ActivityIcon(MenuIcon):
-	def __init__(self, shell, menu_shell, activity_host):
-		self._shell = shell
-		self._activity_host = activity_host
+    def __init__(self, shell, menu_shell, activity_host):
+        self._shell = shell
+        self._activity_host = activity_host
 
-		icon_name = activity_host.get_icon_name()
-		icon_color = activity_host.get_icon_color()
+        icon_name = activity_host.get_icon_name()
+        icon_color = activity_host.get_icon_color()
 
-		MenuIcon.__init__(self, menu_shell, icon_name=icon_name,
-						  color=icon_color)
+        MenuIcon.__init__(self, menu_shell, icon_name=icon_name,
+                          color=icon_color)
 
-	def create_menu(self):
-		menu = ActivityMenu(self._activity_host)
-		menu.connect('action', self._action_cb)
-		return menu
+    def create_menu(self):
+        menu = ActivityMenu(self._activity_host)
+        menu.connect('action', self._action_cb)
+        return menu
 
-	def _action_cb(self, menu, action):
-		self.popdown()
+    def _action_cb(self, menu, action):
+        self.popdown()
 
-		activity = self._shell.get_current_activity()
-		if activity == None:
-			return
+        activity = self._shell.get_current_activity()
+        if activity == None:
+            return
 
-		if action == ActivityMenu.ACTION_SHARE:
-			activity.share()
-		if action == ActivityMenu.ACTION_CLOSE:
-			activity.close()
+        if action == ActivityMenu.ACTION_SHARE:
+            activity.share()
+        if action == ActivityMenu.ACTION_CLOSE:
+            activity.close()
 
 class ZoomBox(hippo.CanvasBox):
-	def __init__(self, shell, menu_shell):
-		hippo.CanvasBox.__init__(self, orientation=hippo.ORIENTATION_HORIZONTAL)
-
-		self._shell = shell
-		self._menu_shell = menu_shell
-		self._activity_icon = None
-
-		icon = CanvasIcon(icon_name='stock-zoom-mesh')
-		style.apply_stylesheet(icon, 'frame.ZoomIcon')
-		icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_MESH)
-		self.append(icon)
-
-		icon = CanvasIcon(icon_name='stock-zoom-friends')
-		style.apply_stylesheet(icon, 'frame.ZoomIcon')
-		icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_FRIENDS)
-		self.append(icon)
-
-		icon = CanvasIcon(icon_name='stock-zoom-home')
-		style.apply_stylesheet(icon, 'frame.ZoomIcon')
-		icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_HOME)
-		self.append(icon)
-
-		icon = CanvasIcon(icon_name='stock-zoom-activity')
-		style.apply_stylesheet(icon, 'frame.ZoomIcon')
-		icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_ACTIVITY)
-		self.append(icon)
-
-		shell.connect('activity-changed', self._activity_changed_cb)
-		self._set_current_activity(shell.get_current_activity())
-
-	def _set_current_activity(self, activity):
-		if self._activity_icon:
-			self.remove(self._activity_icon)
-
-		if activity:
-			icon = ActivityIcon(self._shell, self._menu_shell, activity)
-			style.apply_stylesheet(icon, 'frame.ZoomIcon')
-			self.append(icon, 0)
-			self._activity_icon = icon
-		else:
-			self._activity_icon = None
-
-	def _activity_changed_cb(self, shell_model, activity):
-		self._set_current_activity(activity)
-
-	def _level_clicked_cb(self, item, level):
-		self._shell.set_zoom_level(level)
+    def __init__(self, shell, menu_shell):
+        hippo.CanvasBox.__init__(self, orientation=hippo.ORIENTATION_HORIZONTAL)
+
+        self._shell = shell
+        self._menu_shell = menu_shell
+        self._activity_icon = None
+
+        icon = CanvasIcon(icon_name='stock-zoom-mesh')
+        style.apply_stylesheet(icon, 'frame.ZoomIcon')
+        icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_MESH)
+        self.append(icon)
+
+        icon = CanvasIcon(icon_name='stock-zoom-friends')
+        style.apply_stylesheet(icon, 'frame.ZoomIcon')
+        icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_FRIENDS)
+        self.append(icon)
+
+        icon = CanvasIcon(icon_name='stock-zoom-home')
+        style.apply_stylesheet(icon, 'frame.ZoomIcon')
+        icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_HOME)
+        self.append(icon)
+
+        icon = CanvasIcon(icon_name='stock-zoom-activity')
+        style.apply_stylesheet(icon, 'frame.ZoomIcon')
+        icon.connect('activated', self._level_clicked_cb, sugar.ZOOM_ACTIVITY)
+        self.append(icon)
+
+        shell.connect('activity-changed', self._activity_changed_cb)
+        self._set_current_activity(shell.get_current_activity())
+
+    def _set_current_activity(self, activity):
+        if self._activity_icon:
+            self.remove(self._activity_icon)
+
+        if activity:
+            icon = ActivityIcon(self._shell, self._menu_shell, activity)
+            style.apply_stylesheet(icon, 'frame.ZoomIcon')
+            self.append(icon, 0)
+            self._activity_icon = icon
+        else:
+            self._activity_icon = None
+
+    def _activity_changed_cb(self, shell_model, activity):
+        self._set_current_activity(activity)
+
+    def _level_clicked_cb(self, item, level):
+        self._shell.set_zoom_level(level)
diff --git a/shell/view/frame/notificationtray.py b/shell/view/frame/notificationtray.py
index 5fa5123..b304868 100644
--- a/shell/view/frame/notificationtray.py
+++ b/shell/view/frame/notificationtray.py
@@ -3,16 +3,16 @@ import gtk
 from _sugar import TrayManager
 
 class NotificationTray(gtk.HBox):
-	def __init__(self):
-		gtk.HBox.__init__(self)
+    def __init__(self):
+        gtk.HBox.__init__(self)
 
-		self._manager = TrayManager()
-		self._manager.connect('tray-icon-added', self._icon_added_cb)
-		self._manager.connect('tray-icon-removed', self._icon_removed_cb)
-		self._manager.manage_screen(gtk.gdk.screen_get_default())
+        self._manager = TrayManager()
+        self._manager.connect('tray-icon-added', self._icon_added_cb)
+        self._manager.connect('tray-icon-removed', self._icon_removed_cb)
+        self._manager.manage_screen(gtk.gdk.screen_get_default())
 
-	def _icon_added_cb(self, manager, icon):
-		self.pack_start(icon, False)
+    def _icon_added_cb(self, manager, icon):
+        self.pack_start(icon, False)
 
-	def _icon_removed_cb(self, manager, icon):
-		icon.destroy()
+    def _icon_removed_cb(self, manager, icon):
+        icon.destroy()
diff --git a/shell/view/frame/overlaybox.py b/shell/view/frame/overlaybox.py
index eaa1e5d..406173a 100644
--- a/shell/view/frame/overlaybox.py
+++ b/shell/view/frame/overlaybox.py
@@ -4,15 +4,15 @@ from sugar.graphics import style
 from sugar.graphics.canvasicon import CanvasIcon
 
 class OverlayBox(hippo.CanvasBox):
-	def __init__(self, shell):
-		hippo.CanvasBox.__init__(self, orientation=hippo.ORIENTATION_HORIZONTAL)
+    def __init__(self, shell):
+        hippo.CanvasBox.__init__(self, orientation=hippo.ORIENTATION_HORIZONTAL)
 
-		self._shell = shell
+        self._shell = shell
 
-		icon = CanvasIcon(icon_name='stock-chat')
-		style.apply_stylesheet(icon, 'frame.OverlayIcon')
-		icon.connect('activated', self._overlay_clicked_cb)
-		self.append(icon)
+        icon = CanvasIcon(icon_name='stock-chat')
+        style.apply_stylesheet(icon, 'frame.OverlayIcon')
+        icon.connect('activated', self._overlay_clicked_cb)
+        self.append(icon)
 
-	def _overlay_clicked_cb(self, item):
-		self._shell.toggle_chat_visibility()
+    def _overlay_clicked_cb(self, item):
+        self._shell.toggle_chat_visibility()
diff --git a/shell/view/frame/shutdownicon.py b/shell/view/frame/shutdownicon.py
index 520ba20..5814f72 100644
--- a/shell/view/frame/shutdownicon.py
+++ b/shell/view/frame/shutdownicon.py
@@ -21,24 +21,24 @@ from sugar.graphics.menu import Menu
 from sugar.graphics import style
 
 class ShutdownIcon(MenuIcon):
-	ACTION_SHUTDOWN = 2
+    ACTION_SHUTDOWN = 2
 
-	def __init__(self, menu_shell):
-		MenuIcon.__init__(self, menu_shell, icon_name='stock-close')
-		style.apply_stylesheet(self, 'menu.ActionIcon')
+    def __init__(self, menu_shell):
+        MenuIcon.__init__(self, menu_shell, icon_name='stock-close')
+        style.apply_stylesheet(self, 'menu.ActionIcon')
 
-	def create_menu(self):
-		menu = Menu()
-		menu.add_item('Shut Down', ShutdownIcon.ACTION_SHUTDOWN)
-		menu.connect('action', self._action_cb)
-		return menu
+    def create_menu(self):
+        menu = Menu()
+        menu.add_item('Shut Down', ShutdownIcon.ACTION_SHUTDOWN)
+        menu.connect('action', self._action_cb)
+        return menu
 
-	def _action_cb(self, menu, action):
-		self.popdown()
+    def _action_cb(self, menu, action):
+        self.popdown()
 
-		if action == ShutdownIcon.ACTION_SHUTDOWN:
-			bus = dbus.SystemBus()
-			proxy = bus.get_object('org.freedesktop.Hal',
-								   '/org/freedesktop/Hal/devices/computer')
-			mgr = dbus.Interface(proxy, 'org.freedesktop.Hal.Device.SystemPowerManagement')
-			mgr.Shutdown()
+        if action == ShutdownIcon.ACTION_SHUTDOWN:
+            bus = dbus.SystemBus()
+            proxy = bus.get_object('org.freedesktop.Hal',
+                                   '/org/freedesktop/Hal/devices/computer')
+            mgr = dbus.Interface(proxy, 'org.freedesktop.Hal.Device.SystemPowerManagement')
+            mgr.Shutdown()
diff --git a/shell/view/home/FriendView.py b/shell/view/home/FriendView.py
index 2b5cf7c..6d24f76 100644
--- a/shell/view/home/FriendView.py
+++ b/shell/view/home/FriendView.py
@@ -23,67 +23,67 @@ from sugar.graphics import style
 from sugar.presence import PresenceService
 
 class FriendView(hippo.CanvasBox):
-	def __init__(self, shell, menu_shell, buddy, **kwargs):
-		hippo.CanvasBox.__init__(self, **kwargs)
+    def __init__(self, shell, menu_shell, buddy, **kwargs):
+        hippo.CanvasBox.__init__(self, **kwargs)
 
-		self._pservice = PresenceService.get_instance()
+        self._pservice = PresenceService.get_instance()
 
-		self._buddy = buddy
-		self._buddy_icon = BuddyIcon(shell, menu_shell, buddy)
-		style.apply_stylesheet(self._buddy_icon, 'friends.FriendIcon')
-		self.append(self._buddy_icon)
+        self._buddy = buddy
+        self._buddy_icon = BuddyIcon(shell, menu_shell, buddy)
+        style.apply_stylesheet(self._buddy_icon, 'friends.FriendIcon')
+        self.append(self._buddy_icon)
 
-		self._activity_icon = CanvasIcon()
-		style.apply_stylesheet(self._activity_icon, 'friends.ActivityIcon')
-		self._activity_icon_visible = False
+        self._activity_icon = CanvasIcon()
+        style.apply_stylesheet(self._activity_icon, 'friends.ActivityIcon')
+        self._activity_icon_visible = False
 
-		if self._buddy.is_present():
-			self._buddy_appeared_cb(buddy)
+        if self._buddy.is_present():
+            self._buddy_appeared_cb(buddy)
 
-		self._buddy.connect('current-activity-changed', self._buddy_activity_changed_cb)
-		self._buddy.connect('appeared', self._buddy_appeared_cb)
-		self._buddy.connect('disappeared', self._buddy_disappeared_cb)
-		self._buddy.connect('color-changed', self._buddy_color_changed_cb)
+        self._buddy.connect('current-activity-changed', self._buddy_activity_changed_cb)
+        self._buddy.connect('appeared', self._buddy_appeared_cb)
+        self._buddy.connect('disappeared', self._buddy_disappeared_cb)
+        self._buddy.connect('color-changed', self._buddy_color_changed_cb)
 
-	def _get_new_icon_name(self, activity):
-		# FIXME: do something better here; we probably need to use "flagship"
-		# services like mDNS where activities default services are marked
-		# somehow.
-		activity_registry = shell.get_model().get_bundle_registry()
-		for serv in activity.get_services():
-			bundle = activity_registry.get_bundle(serv.get_type())
-			if bundle:
-				return bundle.get_icon()
-		return None
+    def _get_new_icon_name(self, activity):
+        # FIXME: do something better here; we probably need to use "flagship"
+        # services like mDNS where activities default services are marked
+        # somehow.
+        activity_registry = shell.get_model().get_bundle_registry()
+        for serv in activity.get_services():
+            bundle = activity_registry.get_bundle(serv.get_type())
+            if bundle:
+                return bundle.get_icon()
+        return None
 
-	def _remove_activity_icon(self):
-		if self._activity_icon_visible:
-			self.remove(self._activity_icon)
-			self._activity_icon_visible = False
+    def _remove_activity_icon(self):
+        if self._activity_icon_visible:
+            self.remove(self._activity_icon)
+            self._activity_icon_visible = False
 
-	def _buddy_activity_changed_cb(self, buddy, activity=None):
-		if not activity:
-			self._remove_activity_icon()
-			return
+    def _buddy_activity_changed_cb(self, buddy, activity=None):
+        if not activity:
+            self._remove_activity_icon()
+            return
 
-		# FIXME: use some sort of "unknown activity" icon rather
-		# than hiding the icon?
-		name = self._get_new_icon_name(activity)
-		if name:
-			self._activity_icon.props.icon_name = name
-			self._activity_icon.props.color = buddy.get_color()
-			if not self._activity_icon_visible:
-				self.append(self._activity_icon, hippo.PACK_EXPAND)
-				self._activity_icon_visible = True
-		else:
-			self._remove_activity_icon()
+        # FIXME: use some sort of "unknown activity" icon rather
+        # than hiding the icon?
+        name = self._get_new_icon_name(activity)
+        if name:
+            self._activity_icon.props.icon_name = name
+            self._activity_icon.props.color = buddy.get_color()
+            if not self._activity_icon_visible:
+                self.append(self._activity_icon, hippo.PACK_EXPAND)
+                self._activity_icon_visible = True
+        else:
+            self._remove_activity_icon()
 
-	def _buddy_appeared_cb(self, buddy):
-		activity = self._buddy.get_current_activity()
-		self._buddy_activity_changed_cb(buddy, activity)
+    def _buddy_appeared_cb(self, buddy):
+        activity = self._buddy.get_current_activity()
+        self._buddy_activity_changed_cb(buddy, activity)
 
-	def _buddy_disappeared_cb(self, buddy):
-		self._buddy_activity_changed_cb(buddy, None)
+    def _buddy_disappeared_cb(self, buddy):
+        self._buddy_activity_changed_cb(buddy, None)
 
-	def _buddy_color_changed_cb(self, buddy, color):
-		self._activity_icon.props.color = buddy.get_color()
+    def _buddy_color_changed_cb(self, buddy, color):
+        self._activity_icon.props.color = buddy.get_color()
diff --git a/shell/view/home/FriendsBox.py b/shell/view/home/FriendsBox.py
index 28a745e..ec4aad6 100644
--- a/shell/view/home/FriendsBox.py
+++ b/shell/view/home/FriendsBox.py
@@ -25,42 +25,42 @@ from view.home.MyIcon import MyIcon
 from view.home.FriendView import FriendView
 
 class FriendsBox(SpreadBox, hippo.CanvasItem):
-	__gtype_name__ = 'SugarFriendsBox'
-	def __init__(self, shell, menu_shell):
-		SpreadBox.__init__(self, background_color=0xe2e2e2ff)
+    __gtype_name__ = 'SugarFriendsBox'
+    def __init__(self, shell, menu_shell):
+        SpreadBox.__init__(self, background_color=0xe2e2e2ff)
 
-		self._shell = shell
-		self._menu_shell = menu_shell
-		self._friends = {}
+        self._shell = shell
+        self._menu_shell = menu_shell
+        self._friends = {}
 
-		self._my_icon = MyIcon()
-		style.apply_stylesheet(self._my_icon, 'friends.MyIcon')
-		self.append(self._my_icon, hippo.PACK_FIXED)
+        self._my_icon = MyIcon()
+        style.apply_stylesheet(self._my_icon, 'friends.MyIcon')
+        self.append(self._my_icon, hippo.PACK_FIXED)
 
-		friends = self._shell.get_model().get_friends()
+        friends = self._shell.get_model().get_friends()
 
-		for friend in friends:
-			self.add_friend(friend)
+        for friend in friends:
+            self.add_friend(friend)
 
-		friends.connect('friend-added', self._friend_added_cb)
-		friends.connect('friend-removed', self._friend_removed_cb)
+        friends.connect('friend-added', self._friend_added_cb)
+        friends.connect('friend-removed', self._friend_removed_cb)
 
-	def add_friend(self, buddy_info):
-		icon = FriendView(self._shell, self._menu_shell, buddy_info)
-		self.add_item(icon)
+    def add_friend(self, buddy_info):
+        icon = FriendView(self._shell, self._menu_shell, buddy_info)
+        self.add_item(icon)
 
-		self._friends[buddy_info.get_name()] = icon
+        self._friends[buddy_info.get_name()] = icon
 
-	def _friend_added_cb(self, data_model, buddy_info):
-		self.add_friend(buddy_info)
+    def _friend_added_cb(self, data_model, buddy_info):
+        self.add_friend(buddy_info)
 
-	def _friend_removed_cb(self, data_model, name):
-		self.remove_item(self._friends[name])
-		del self._friends[name]
+    def _friend_removed_cb(self, data_model, name):
+        self.remove_item(self._friends[name])
+        del self._friends[name]
 
-	def do_allocate(self, width, height):
-		SpreadBox.do_allocate(self, width, height)
+    def do_allocate(self, width, height):
+        SpreadBox.do_allocate(self, width, height)
 
-		[icon_width, icon_height] = self._my_icon.get_allocation()
-		self.move(self._my_icon, (width - icon_width) / 2,
-				  (height - icon_height) / 2)
+        [icon_width, icon_height] = self._my_icon.get_allocation()
+        self.move(self._my_icon, (width - icon_width) / 2,
+                  (height - icon_height) / 2)
diff --git a/shell/view/home/HomeBox.py b/shell/view/home/HomeBox.py
index 146056b..a24402d 100644
--- a/shell/view/home/HomeBox.py
+++ b/shell/view/home/HomeBox.py
@@ -22,24 +22,24 @@ from sugar.graphics.grid import Grid
 from sugar.graphics import style
 
 class HomeBox(hippo.CanvasBox, hippo.CanvasItem):
-	__gtype_name__ = 'SugarHomeBox'
+    __gtype_name__ = 'SugarHomeBox'
 
-	def __init__(self, shell):
-		hippo.CanvasBox.__init__(self, background_color=0xe2e2e2ff,
-								 yalign=2)
+    def __init__(self, shell):
+        hippo.CanvasBox.__init__(self, background_color=0xe2e2e2ff,
+                                 yalign=2)
 
-		grid = Grid()
-		donut = ActivitiesDonut(shell, box_width=grid.dimension(7),
-								box_height=grid.dimension(7))
-		self.append(donut)
+        grid = Grid()
+        donut = ActivitiesDonut(shell, box_width=grid.dimension(7),
+                                box_height=grid.dimension(7))
+        self.append(donut)
 
-		self._my_icon = MyIcon()
-		style.apply_stylesheet(self._my_icon, 'home.MyIcon')
-		self.append(self._my_icon, hippo.PACK_FIXED)
+        self._my_icon = MyIcon()
+        style.apply_stylesheet(self._my_icon, 'home.MyIcon')
+        self.append(self._my_icon, hippo.PACK_FIXED)
 
-	def do_allocate(self, width, height):
-		hippo.CanvasBox.do_allocate(self, width, height)
+    def do_allocate(self, width, height):
+        hippo.CanvasBox.do_allocate(self, width, height)
 
-		[icon_width, icon_height] = self._my_icon.get_allocation()
-		self.move(self._my_icon, (width - icon_width) / 2,
-				  (height - icon_height) / 2)
+        [icon_width, icon_height] = self._my_icon.get_allocation()
+        self.move(self._my_icon, (width - icon_width) / 2,
+                  (height - icon_height) / 2)
diff --git a/shell/view/home/HomeWindow.py b/shell/view/home/HomeWindow.py
index e07c7d0..b450b8c 100644
--- a/shell/view/home/HomeWindow.py
+++ b/shell/view/home/HomeWindow.py
@@ -25,45 +25,45 @@ from view.home.HomeBox import HomeBox
 from view.home.FriendsBox import FriendsBox
 
 class HomeWindow(gtk.Window):
-	def __init__(self, shell):
-		gtk.Window.__init__(self)
-		self._shell = shell
+    def __init__(self, shell):
+        gtk.Window.__init__(self)
+        self._shell = shell
 
-		self.set_default_size(gtk.gdk.screen_width(),
-							  gtk.gdk.screen_height())
+        self.set_default_size(gtk.gdk.screen_width(),
+                              gtk.gdk.screen_height())
 
-		self.realize()
-		self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DESKTOP)
+        self.realize()
+        self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DESKTOP)
 
-		self._nb = gtk.Notebook()
-		self._nb.set_show_border(False)
-		self._nb.set_show_tabs(False)
+        self._nb = gtk.Notebook()
+        self._nb.set_show_border(False)
+        self._nb.set_show_tabs(False)
 
-		self.add(self._nb)
-		self._nb.show()
+        self.add(self._nb)
+        self._nb.show()
 
-		canvas = hippo.Canvas()
-		box = HomeBox(shell)
-		canvas.set_root(box)
-		self._nb.append_page(canvas)
-		canvas.show()
+        canvas = hippo.Canvas()
+        box = HomeBox(shell)
+        canvas.set_root(box)
+        self._nb.append_page(canvas)
+        canvas.show()
 
-		canvas = hippo.Canvas()
-		box = FriendsBox(shell, MenuShell(canvas))
-		canvas.set_root(box)
-		self._nb.append_page(canvas)
-		canvas.show()
+        canvas = hippo.Canvas()
+        box = FriendsBox(shell, MenuShell(canvas))
+        canvas.set_root(box)
+        self._nb.append_page(canvas)
+        canvas.show()
 
-		canvas = hippo.Canvas()
-		box = MeshBox(shell, MenuShell(canvas))
-		canvas.set_root(box)
-		self._nb.append_page(canvas)
-		canvas.show()
+        canvas = hippo.Canvas()
+        box = MeshBox(shell, MenuShell(canvas))
+        canvas.set_root(box)
+        self._nb.append_page(canvas)
+        canvas.show()
 
-	def set_zoom_level(self, level):
-		if level == sugar.ZOOM_HOME:
-			self._nb.set_current_page(0)
-		elif level == sugar.ZOOM_FRIENDS:
-			self._nb.set_current_page(1)
-		elif level == sugar.ZOOM_MESH:
-			self._nb.set_current_page(2)
+    def set_zoom_level(self, level):
+        if level == sugar.ZOOM_HOME:
+            self._nb.set_current_page(0)
+        elif level == sugar.ZOOM_FRIENDS:
+            self._nb.set_current_page(1)
+        elif level == sugar.ZOOM_MESH:
+            self._nb.set_current_page(2)
diff --git a/shell/view/home/MeshBox.py b/shell/view/home/MeshBox.py
index 1c61d1a..5ea4aef 100644
--- a/shell/view/home/MeshBox.py
+++ b/shell/view/home/MeshBox.py
@@ -25,116 +25,116 @@ from sugar.graphics.canvasicon import CanvasIcon
 from view.BuddyIcon import BuddyIcon
 
 class ActivityView(SnowflakeBox):
-	def __init__(self, shell, menu_shell, model):
-		SnowflakeBox.__init__(self)
+    def __init__(self, shell, menu_shell, model):
+        SnowflakeBox.__init__(self)
 
-		self._shell = shell
-		self._model = model
-		self._icons = {}
+        self._shell = shell
+        self._model = model
+        self._icons = {}
 
-		icon = CanvasIcon(icon_name=model.get_icon_name(),
-						  color=model.get_color(), size=80)
-		icon.connect('activated', self._clicked_cb)
-		self.append(icon, hippo.PACK_FIXED)
-		self.set_root(icon)
+        icon = CanvasIcon(icon_name=model.get_icon_name(),
+                          color=model.get_color(), size=80)
+        icon.connect('activated', self._clicked_cb)
+        self.append(icon, hippo.PACK_FIXED)
+        self.set_root(icon)
 
-	def has_buddy_icon(self, name):
-		return self._icons.has_key(name)
+    def has_buddy_icon(self, name):
+        return self._icons.has_key(name)
 
-	def add_buddy_icon(self, name, icon):
-		self._icons[name] = icon
-		self.append(icon, hippo.PACK_FIXED)
+    def add_buddy_icon(self, name, icon):
+        self._icons[name] = icon
+        self.append(icon, hippo.PACK_FIXED)
 
-	def remove_buddy_icon(self, name):
-		icon = self._icons[name]
-		self.remove(icon)
-		del self._icons[name]
+    def remove_buddy_icon(self, name):
+        icon = self._icons[name]
+        self.remove(icon)
+        del self._icons[name]
 
-	def _clicked_cb(self, item):
-		bundle_id = self._model.get_service().get_type()
-		self._shell.join_activity(bundle_id, self._model.get_id())
+    def _clicked_cb(self, item):
+        bundle_id = self._model.get_service().get_type()
+        self._shell.join_activity(bundle_id, self._model.get_id())
 
 class MeshBox(SpreadBox):
-	def __init__(self, shell, menu_shell):
-		SpreadBox.__init__(self, background_color=0xe2e2e2ff)
+    def __init__(self, shell, menu_shell):
+        SpreadBox.__init__(self, background_color=0xe2e2e2ff)
 
-		self._shell = shell
-		self._menu_shell = menu_shell
-		self._model = shell.get_model().get_mesh()
-		self._buddies = {}
-		self._activities = {}
-		self._buddy_to_activity = {}
+        self._shell = shell
+        self._menu_shell = menu_shell
+        self._model = shell.get_model().get_mesh()
+        self._buddies = {}
+        self._activities = {}
+        self._buddy_to_activity = {}
 
-		for buddy_model in self._model.get_buddies():
-			self._add_alone_buddy(buddy_model)
+        for buddy_model in self._model.get_buddies():
+            self._add_alone_buddy(buddy_model)
 
-		self._model.connect('buddy-added', self._buddy_added_cb)
-		self._model.connect('buddy-removed', self._buddy_removed_cb)
-		self._model.connect('buddy-moved', self._buddy_moved_cb)
+        self._model.connect('buddy-added', self._buddy_added_cb)
+        self._model.connect('buddy-removed', self._buddy_removed_cb)
+        self._model.connect('buddy-moved', self._buddy_moved_cb)
 
-		for activity_model in self._model.get_activities():
-			self._add_activity(activity_model)
+        for activity_model in self._model.get_activities():
+            self._add_activity(activity_model)
 
-		self._model.connect('activity-added', self._activity_added_cb)
-		self._model.connect('activity-removed', self._activity_removed_cb)
+        self._model.connect('activity-added', self._activity_added_cb)
+        self._model.connect('activity-removed', self._activity_removed_cb)
 
-	def _buddy_added_cb(self, model, buddy_model):
-		self._add_alone_buddy(buddy_model)
+    def _buddy_added_cb(self, model, buddy_model):
+        self._add_alone_buddy(buddy_model)
 
-	def _buddy_removed_cb(self, model, buddy_model):
-		self._remove_buddy(buddy_model) 
+    def _buddy_removed_cb(self, model, buddy_model):
+        self._remove_buddy(buddy_model) 
 
-	def _buddy_moved_cb(self, model, buddy_model, activity_model):
-		self._move_buddy(buddy_model, activity_model)
+    def _buddy_moved_cb(self, model, buddy_model, activity_model):
+        self._move_buddy(buddy_model, activity_model)
 
-	def _activity_added_cb(self, model, activity_model):
-		self._add_activity(activity_model)
+    def _activity_added_cb(self, model, activity_model):
+        self._add_activity(activity_model)
 
-	def _activity_removed_cb(self, model, activity_model):
-		self._remove_activity(activity_model) 
+    def _activity_removed_cb(self, model, activity_model):
+        self._remove_activity(activity_model) 
 
-	def _add_alone_buddy(self, buddy_model):
-		icon = BuddyIcon(self._shell, self._menu_shell, buddy_model)
-		icon.props.size = 80
-		self.add_item(icon)
+    def _add_alone_buddy(self, buddy_model):
+        icon = BuddyIcon(self._shell, self._menu_shell, buddy_model)
+        icon.props.size = 80
+        self.add_item(icon)
 
-		self._buddies[buddy_model.get_name()] = icon
+        self._buddies[buddy_model.get_name()] = icon
 
-	def _remove_alone_buddy(self, buddy_model):
-		icon = self._buddies[buddy_model.get_name()]
-		self.remove_item(icon)
-		del self._buddies[buddy_model.get_name()]
+    def _remove_alone_buddy(self, buddy_model):
+        icon = self._buddies[buddy_model.get_name()]
+        self.remove_item(icon)
+        del self._buddies[buddy_model.get_name()]
 
-	def _remove_buddy(self, buddy_model):
-		name = buddy_model.get_name()
-		if self._buddies.has_key(name):
-			self._remove_alone_buddy(buddy_model)
-		else:
-			for activity in self._activities.values():
-				if activity.has_buddy_icon(name):
-					activity.remove_buddy_icon(name)
+    def _remove_buddy(self, buddy_model):
+        name = buddy_model.get_name()
+        if self._buddies.has_key(name):
+            self._remove_alone_buddy(buddy_model)
+        else:
+            for activity in self._activities.values():
+                if activity.has_buddy_icon(name):
+                    activity.remove_buddy_icon(name)
 
-	def _move_buddy(self, buddy_model, activity_model):
-		name = buddy_model.get_name()
+    def _move_buddy(self, buddy_model, activity_model):
+        name = buddy_model.get_name()
 
-		self._remove_buddy(buddy_model)
+        self._remove_buddy(buddy_model)
 
-		if activity_model == None:
-			self._add_alone_buddy(buddy_model)
-		else:
-			activity = self._activities[activity_model.get_id()]
+        if activity_model == None:
+            self._add_alone_buddy(buddy_model)
+        else:
+            activity = self._activities[activity_model.get_id()]
 
-			icon = BuddyIcon(self._shell, self._menu_shell, buddy_model)
-			icon.props.size = 60
-			activity.add_buddy_icon(buddy_model.get_name(), icon)
+            icon = BuddyIcon(self._shell, self._menu_shell, buddy_model)
+            icon.props.size = 60
+            activity.add_buddy_icon(buddy_model.get_name(), icon)
 
-	def _add_activity(self, activity_model):
-		icon = ActivityView(self._shell, self._menu_shell, activity_model)
-		self.add_item(icon)
+    def _add_activity(self, activity_model):
+        icon = ActivityView(self._shell, self._menu_shell, activity_model)
+        self.add_item(icon)
 
-		self._activities[activity_model.get_id()] = icon
+        self._activities[activity_model.get_id()] = icon
 
-	def _remove_activity(self, activity_model):
-		icon = self._activities[activity_model.get_id()]
-		self.remove_item(icon)
-		del self._activities[activity_model.get_id()]
+    def _remove_activity(self, activity_model):
+        icon = self._activities[activity_model.get_id()]
+        self.remove_item(icon)
+        del self._activities[activity_model.get_id()]
diff --git a/shell/view/home/MyIcon.py b/shell/view/home/MyIcon.py
index df59317..80e3a04 100644
--- a/shell/view/home/MyIcon.py
+++ b/shell/view/home/MyIcon.py
@@ -18,6 +18,6 @@ from sugar.graphics.canvasicon import CanvasIcon
 from sugar import profile
 
 class MyIcon(CanvasIcon):
-	def __init__(self):
-		CanvasIcon.__init__(self, icon_name='stock-buddy',
-					  	    color=profile.get_color())
+    def __init__(self):
+        CanvasIcon.__init__(self, icon_name='stock-buddy',
+                              color=profile.get_color())
diff --git a/shell/view/home/activitiesdonut.py b/shell/view/home/activitiesdonut.py
index f7d24fc..74f3bbb 100644
--- a/shell/view/home/activitiesdonut.py
+++ b/shell/view/home/activitiesdonut.py
@@ -21,100 +21,100 @@ from sugar.graphics.canvasicon import CanvasIcon
 from sugar.graphics import style
 
 class ActivitiesDonut(hippo.CanvasBox, hippo.CanvasItem):
-	__gtype_name__ = 'SugarActivitiesDonut'
-	def __init__(self, shell, **kwargs):
-		hippo.CanvasBox.__init__(self, **kwargs)
+    __gtype_name__ = 'SugarActivitiesDonut'
+    def __init__(self, shell, **kwargs):
+        hippo.CanvasBox.__init__(self, **kwargs)
 
-		self._activities = {}
+        self._activities = {}
 
-		shell.connect('activity_opened', self.__activity_opened_cb)
-		shell.connect('activity_closed', self.__activity_closed_cb)
+        shell.connect('activity_opened', self.__activity_opened_cb)
+        shell.connect('activity_closed', self.__activity_closed_cb)
 
-	def __activity_opened_cb(self, model, activity):
-		self._add_activity(activity)
+    def __activity_opened_cb(self, model, activity):
+        self._add_activity(activity)
 
-	def __activity_closed_cb(self, model, activity):
-		self._remove_activity(activity)
-	
-	def _remove_activity(self, activity):
-		icon = self._activities[activity.get_id()]
-		self.remove(icon)
-		del self._activities[activity.get_id()]
+    def __activity_closed_cb(self, model, activity):
+        self._remove_activity(activity)
+    
+    def _remove_activity(self, activity):
+        icon = self._activities[activity.get_id()]
+        self.remove(icon)
+        del self._activities[activity.get_id()]
 
-	def _add_activity(self, activity):
-		icon_name = activity.get_icon_name()
-		icon_color = activity.get_icon_color()
+    def _add_activity(self, activity):
+        icon_name = activity.get_icon_name()
+        icon_color = activity.get_icon_color()
 
-		icon = CanvasIcon(icon_name=icon_name, color=icon_color)
-		style.apply_stylesheet(icon, 'ring.ActivityIcon')
-		icon.connect('activated', self.__activity_icon_clicked_cb, activity)
-		self.append(icon, hippo.PACK_FIXED)
+        icon = CanvasIcon(icon_name=icon_name, color=icon_color)
+        style.apply_stylesheet(icon, 'ring.ActivityIcon')
+        icon.connect('activated', self.__activity_icon_clicked_cb, activity)
+        self.append(icon, hippo.PACK_FIXED)
 
-		self._activities[activity.get_id()] = icon
+        self._activities[activity.get_id()] = icon
 
-		self.emit_paint_needed(0, 0, -1, -1)
+        self.emit_paint_needed(0, 0, -1, -1)
 
-	def __activity_icon_clicked_cb(self, item, activity):
-		activity.present()
+    def __activity_icon_clicked_cb(self, item, activity):
+        activity.present()
 
-	def _get_angles(self, index):
-		angle = 2 * math.pi / 8
-		return [index * angle, (index + 1) * angle]
+    def _get_angles(self, index):
+        angle = 2 * math.pi / 8
+        return [index * angle, (index + 1) * angle]
 
-	def _get_radius(self):
-		[width, height] = self.get_allocation()
-		return min(width, height) / 2
+    def _get_radius(self):
+        [width, height] = self.get_allocation()
+        return min(width, height) / 2
 
-	def _get_inner_radius(self):
-		return self._get_radius() * 0.5
+    def _get_inner_radius(self):
+        return self._get_radius() * 0.5
 
-	def do_paint_below_children(self, cr, damaged_box):
-		[width, height] = self.get_allocation()
+    def do_paint_below_children(self, cr, damaged_box):
+        [width, height] = self.get_allocation()
 
-		cr.translate(width / 2, height / 2)
+        cr.translate(width / 2, height / 2)
 
-		radius = self._get_radius()
+        radius = self._get_radius()
 
-		cr.set_source_rgb(0xf1 / 255.0, 0xf1 / 255.0, 0xf1 / 255.0)
-		cr.arc(0, 0, radius, 0, 2 * math.pi)
-		cr.fill()
+        cr.set_source_rgb(0xf1 / 255.0, 0xf1 / 255.0, 0xf1 / 255.0)
+        cr.arc(0, 0, radius, 0, 2 * math.pi)
+        cr.fill()
 
-		angle_end = 0
-		for i in range(0, len(self._activities)):
-			[angle_start, angle_end] = self._get_angles(i)
+        angle_end = 0
+        for i in range(0, len(self._activities)):
+            [angle_start, angle_end] = self._get_angles(i)
 
-			cr.new_path()
-			cr.move_to(0, 0)
-			cr.line_to(radius * math.cos(angle_start),
-					   radius * math.sin(angle_start))
-			cr.arc(0, 0, radius, angle_start, angle_end)
-			cr.line_to(0, 0)
+            cr.new_path()
+            cr.move_to(0, 0)
+            cr.line_to(radius * math.cos(angle_start),
+                       radius * math.sin(angle_start))
+            cr.arc(0, 0, radius, angle_start, angle_end)
+            cr.line_to(0, 0)
 
-			cr.set_source_rgb(0xe2 / 255.0, 0xe2 / 255.0, 0xe2 / 255.0)
-			cr.set_line_width(4)
-			cr.stroke_preserve()
+            cr.set_source_rgb(0xe2 / 255.0, 0xe2 / 255.0, 0xe2 / 255.0)
+            cr.set_line_width(4)
+            cr.stroke_preserve()
 
-			cr.set_source_rgb(1, 1, 1)
-			cr.fill()
+            cr.set_source_rgb(1, 1, 1)
+            cr.fill()
 
-		cr.set_source_rgb(0xe2 / 255.0, 0xe2 / 255.0, 0xe2 / 255.0)
-		cr.arc(0, 0, self._get_inner_radius(), 0, 2 * math.pi)
-		cr.fill()
+        cr.set_source_rgb(0xe2 / 255.0, 0xe2 / 255.0, 0xe2 / 255.0)
+        cr.arc(0, 0, self._get_inner_radius(), 0, 2 * math.pi)
+        cr.fill()
 
-	def do_allocate(self, width, height):
-		hippo.CanvasBox.do_allocate(self, width, height)
+    def do_allocate(self, width, height):
+        hippo.CanvasBox.do_allocate(self, width, height)
 
-		radius = (self._get_inner_radius() + self._get_radius()) / 2
+        radius = (self._get_inner_radius() + self._get_radius()) / 2
 
-		i = 0
-		for icon in self._activities.values():
-			[angle_start, angle_end] = self._get_angles(i)
-			angle = angle_start + (angle_end - angle_start) / 2
+        i = 0
+        for icon in self._activities.values():
+            [angle_start, angle_end] = self._get_angles(i)
+            angle = angle_start + (angle_end - angle_start) / 2
 
-			[icon_width, icon_height] = icon.get_allocation()
+            [icon_width, icon_height] = icon.get_allocation()
 
-			x = int(radius * math.cos(angle)) - icon_width / 2
-			y = int(radius * math.sin(angle)) - icon_height / 2
-			self.move(icon, x + width / 2, y + height / 2)
+            x = int(radius * math.cos(angle)) - icon_width / 2
+            y = int(radius * math.sin(angle)) - icon_height / 2
+            self.move(icon, x + width / 2, y + height / 2)
 
-			i += 1
+            i += 1
diff --git a/shell/view/stylesheet.py b/shell/view/stylesheet.py
index 1870f9c..5b1c4c6 100644
--- a/shell/view/stylesheet.py
+++ b/shell/view/stylesheet.py
@@ -21,59 +21,59 @@ from sugar.graphics.iconcolor import IconColor
 from sugar.graphics import style
 
 frame_ActivityIcon = {
-	'color' : IconColor('white'),
-	'size'  : style.standard_icon_size
+    'color' : IconColor('white'),
+    'size'  : style.standard_icon_size
 }
 
 frame_ShutdownIcon = {
-	'size' : style.standard_icon_size
+    'size' : style.standard_icon_size
 }
 
 frame_OverlayIcon = {
-	'size' : style.standard_icon_size
+    'size' : style.standard_icon_size
 }
 
 frame_ZoomIcon = {
-	'size' : style.standard_icon_size
+    'size' : style.standard_icon_size
 }
 
 frame_BuddyIcon = {
-	'size' : style.standard_icon_size
+    'size' : style.standard_icon_size
 }
 
 home_MyIcon = {
-	'size' : style.xlarge_icon_size
+    'size' : style.xlarge_icon_size
 }
 
 ring_ActivityIcon = {
-	'size'  : style.medium_icon_size
+    'size'  : style.medium_icon_size
 }
 
 friends_MyIcon = {
-	'size' : style.large_icon_size
+    'size' : style.large_icon_size
 }
 
 friends_FriendIcon = {
-	'size' : style.large_icon_size
+    'size' : style.large_icon_size
 }
 
 friends_ActivityIcon = {
-	'size' : style.standard_icon_size
+    'size' : style.standard_icon_size
 }
 
 clipboard_bubble = {
-	'fill-color'	: 0x646464FF,
-	'stroke-color'	: 0x646464FF,
-	'progress-color': 0x333333FF,
-	'spacing'		: style.space_unit,
-	'padding'		: style.space_unit * 1.5
+    'fill-color'    : 0x646464FF,
+    'stroke-color'    : 0x646464FF,
+    'progress-color': 0x333333FF,
+    'spacing'        : style.space_unit,
+    'padding'        : style.space_unit * 1.5
 }
 
 clipboard_menu_item_title = {
-	'xalign': hippo.ALIGNMENT_START,
-	'padding-left': 5,
-	'color'	 : 0xFFFFFFFF,
-	'font'	 : style.get_font_description('Bold', 1.2)
+    'xalign': hippo.ALIGNMENT_START,
+    'padding-left': 5,
+    'color'     : 0xFFFFFFFF,
+    'font'     : style.get_font_description('Bold', 1.2)
 }
 
 style.register_stylesheet("clipboard.Bubble", clipboard_bubble)