Changed all tabs to 4 spaces for python style

10 files changed, 3390 insertions, 3390 deletions

diff --git a/services/clipboard/ClipboardService.py b/services/clipboard/ClipboardService.py
index 7389c58..d8a151d 100644
--- a/services/clipboard/ClipboardService.py
+++ b/services/clipboard/ClipboardService.py
@@ -24,53 +24,53 @@ from sugar import env
 
 class ClipboardDBusServiceHelper(dbus.service.Object):
 
-	_CLIPBOARD_DBUS_INTERFACE = "org.laptop.Clipboard"
-	_CLIPBOARD_OBJECT_PATH = "/org/laptop/Clipboard"
+    _CLIPBOARD_DBUS_INTERFACE = "org.laptop.Clipboard"
+    _CLIPBOARD_OBJECT_PATH = "/org/laptop/Clipboard"
 
-	def __init__(self, parent):
-		self._parent = parent
+    def __init__(self, parent):
+        self._parent = parent
 
-		bus = dbus.SessionBus()
-		bus_name = dbus.service.BusName(self._CLIPBOARD_DBUS_INTERFACE, bus=bus)
-		dbus.service.Object.__init__(self, bus_name, self._CLIPBOARD_OBJECT_PATH)
-		
-	@dbus.service.method(_CLIPBOARD_DBUS_INTERFACE,
-						 in_signature="sss", out_signature="")
-	def add_object(self, name, mimeType, fileName):
-		self.object_added(name, mimeType, fileName)
-		logging.debug('Added object of type ' + mimeType + ' with path at ' + fileName)
+        bus = dbus.SessionBus()
+        bus_name = dbus.service.BusName(self._CLIPBOARD_DBUS_INTERFACE, bus=bus)
+        dbus.service.Object.__init__(self, bus_name, self._CLIPBOARD_OBJECT_PATH)
+        
+    @dbus.service.method(_CLIPBOARD_DBUS_INTERFACE,
+                         in_signature="sss", out_signature="")
+    def add_object(self, name, mimeType, fileName):
+        self.object_added(name, mimeType, fileName)
+        logging.debug('Added object of type ' + mimeType + ' with path at ' + fileName)
 
-	@dbus.service.method(_CLIPBOARD_DBUS_INTERFACE,
-						 in_signature="s", out_signature="")
-	def delete_object(self, fileName):
-		self.object_deleted(fileName)
-		logging.debug('Deleted object with path at ' + fileName)
-		
-	@dbus.service.method(_CLIPBOARD_DBUS_INTERFACE,
-						 in_signature="si", out_signature="")
-	def set_object_state(self, fileName, percent):
-		logging.debug('Changed object with path at ' + fileName + ' with percent ' + str(percent))
-		self.object_state_changed(fileName, percent)
+    @dbus.service.method(_CLIPBOARD_DBUS_INTERFACE,
+                         in_signature="s", out_signature="")
+    def delete_object(self, fileName):
+        self.object_deleted(fileName)
+        logging.debug('Deleted object with path at ' + fileName)
+        
+    @dbus.service.method(_CLIPBOARD_DBUS_INTERFACE,
+                         in_signature="si", out_signature="")
+    def set_object_state(self, fileName, percent):
+        logging.debug('Changed object with path at ' + fileName + ' with percent ' + str(percent))
+        self.object_state_changed(fileName, percent)
 
-	@dbus.service.signal(_CLIPBOARD_DBUS_INTERFACE, signature="sss")
-	def object_added(self, name, mimeType, fileName):
-		pass
+    @dbus.service.signal(_CLIPBOARD_DBUS_INTERFACE, signature="sss")
+    def object_added(self, name, mimeType, fileName):
+        pass
 
-	@dbus.service.signal(_CLIPBOARD_DBUS_INTERFACE, signature="s")
-	def object_deleted(self, fileName):
-		pass
+    @dbus.service.signal(_CLIPBOARD_DBUS_INTERFACE, signature="s")
+    def object_deleted(self, fileName):
+        pass
 
-	@dbus.service.signal(_CLIPBOARD_DBUS_INTERFACE, signature="si")
-	def object_state_changed(self, fileName, percent):
-		pass
+    @dbus.service.signal(_CLIPBOARD_DBUS_INTERFACE, signature="si")
+    def object_state_changed(self, fileName, percent):
+        pass
 
 class ClipboardService(object):
-	def __init__(self):
-		self._dbus_helper = ClipboardDBusServiceHelper(self)
+    def __init__(self):
+        self._dbus_helper = ClipboardDBusServiceHelper(self)
 
-	def run(self):
-		loop = gobject.MainLoop()
-		try:
-			loop.run()
-		except KeyboardInterrupt:
-			print 'Ctrl+C pressed, exiting...'
+    def run(self):
+        loop = gobject.MainLoop()
+        try:
+            loop.run()
+        except KeyboardInterrupt:
+            print 'Ctrl+C pressed, exiting...'
diff --git a/services/nm/bubble.py b/services/nm/bubble.py
index 24e68ab..bb44cd0 100644
--- a/services/nm/bubble.py
+++ b/services/nm/bubble.py
@@ -22,111 +22,111 @@ import gtk
 import hippo
 
 class Bubble(hippo.CanvasBox, hippo.CanvasItem):
-	__gtype_name__ = 'NetworkBubble'
-
-	__gproperties__ = {
-		'fill-color': (object, None, None,
-					  gobject.PARAM_READWRITE),
-		'stroke-color': (object, None, None,
-					  gobject.PARAM_READWRITE),
-		'progress-color': (object, None, None,
-					  gobject.PARAM_READWRITE),
-		'percent'   : (object, None, None,
-					  gobject.PARAM_READWRITE),
-	}
-
-	def __init__(self, **kwargs):
-		self._stroke_color = 0xFFFFFFFF
-		self._fill_color = 0xFFFFFFFF
-		self._progress_color = 0x000000FF
-		self._percent = 0
-		self._radius = 8
-
-		hippo.CanvasBox.__init__(self, **kwargs)
-
-	def do_set_property(self, pspec, value):
-		if pspec.name == 'fill-color':
-			self._fill_color = value
-			self.emit_paint_needed(0, 0, -1, -1)
-		elif pspec.name == 'stroke-color':
-			self._stroke_color = value
-			self.emit_paint_needed(0, 0, -1, -1)
-		elif pspec.name == 'progress-color':
-			self._progress_color = value
-			self.emit_paint_needed(0, 0, -1, -1)
-		elif pspec.name == 'percent':
-			self._percent = value
-			self.emit_paint_needed(0, 0, -1, -1)
-
-	def do_get_property(self, pspec):
-		if pspec.name == 'fill-color':
-			return self._fill_color
-		elif pspec.name == 'stroke-color':
-			return self._stroke_color
-		elif pspec.name == 'progress-color':
-			return self._progress_color
-		elif pspec.name == 'percent':
-			return self._percent
-
-	def _int_to_rgb(self, int_color):
-		red = (int_color >> 24) & 0x000000FF
-		green = (int_color >> 16) & 0x000000FF
-		blue = (int_color >> 8) & 0x000000FF
-		alpha = int_color & 0x000000FF
-		return (red / 255.0, green / 255.0, blue / 255.0)
-
-	def do_paint_below_children(self, cr, damaged_box):
-		[width, height] = self.get_allocation()
-
-		line_width = 3.0
-		x = line_width
-		y = line_width
-		width -= line_width * 2
-		height -= line_width * 2
-
-		cr.move_to(x + self._radius, y);
-		cr.arc(x + width - self._radius, y + self._radius,
-			   self._radius, math.pi * 1.5, math.pi * 2);
-		cr.arc(x + width - self._radius, x + height - self._radius,
-			   self._radius, 0, math.pi * 0.5);
-		cr.arc(x + self._radius, y + height - self._radius,
-			   self._radius, math.pi * 0.5, math.pi);
-		cr.arc(x + self._radius, y + self._radius, self._radius,
-			   math.pi, math.pi * 1.5);
-
-		color = self._int_to_rgb(self._fill_color)
-		cr.set_source_rgb(*color)
-		cr.fill_preserve();
-
-		color = self._int_to_rgb(self._stroke_color)
-		cr.set_source_rgb(*color)
-		cr.set_line_width(line_width)
-		cr.stroke();
-
-		if self._percent > 0:
-			self._paint_progress_bar(cr, x, y, width, height, line_width)
-
-	def _paint_progress_bar(self, cr, x, y, width, height, line_width):
-		prog_x = x + line_width
-		prog_y = y + line_width
-		prog_width = (width - (line_width * 2)) * (self._percent / 100.0)
-		prog_height = (height - (line_width * 2))
-
-		x = prog_x
-		y = prog_y
-		width = prog_width
-		height = prog_height
-
-		cr.move_to(x + self._radius, y);
-		cr.arc(x + width - self._radius, y + self._radius,
-			   self._radius, math.pi * 1.5, math.pi * 2);
-		cr.arc(x + width - self._radius, x + height - self._radius,
-			   self._radius, 0, math.pi * 0.5);
-		cr.arc(x + self._radius, y + height - self._radius,
-			   self._radius, math.pi * 0.5, math.pi);
-		cr.arc(x + self._radius, y + self._radius, self._radius,
-			   math.pi, math.pi * 1.5);
-
-		color = self._int_to_rgb(self._progress_color)
-		cr.set_source_rgb(*color)
-		cr.fill_preserve();
+    __gtype_name__ = 'NetworkBubble'
+
+    __gproperties__ = {
+        'fill-color': (object, None, None,
+                      gobject.PARAM_READWRITE),
+        'stroke-color': (object, None, None,
+                      gobject.PARAM_READWRITE),
+        'progress-color': (object, None, None,
+                      gobject.PARAM_READWRITE),
+        'percent'   : (object, None, None,
+                      gobject.PARAM_READWRITE),
+    }
+
+    def __init__(self, **kwargs):
+        self._stroke_color = 0xFFFFFFFF
+        self._fill_color = 0xFFFFFFFF
+        self._progress_color = 0x000000FF
+        self._percent = 0
+        self._radius = 8
+
+        hippo.CanvasBox.__init__(self, **kwargs)
+
+    def do_set_property(self, pspec, value):
+        if pspec.name == 'fill-color':
+            self._fill_color = value
+            self.emit_paint_needed(0, 0, -1, -1)
+        elif pspec.name == 'stroke-color':
+            self._stroke_color = value
+            self.emit_paint_needed(0, 0, -1, -1)
+        elif pspec.name == 'progress-color':
+            self._progress_color = value
+            self.emit_paint_needed(0, 0, -1, -1)
+        elif pspec.name == 'percent':
+            self._percent = value
+            self.emit_paint_needed(0, 0, -1, -1)
+
+    def do_get_property(self, pspec):
+        if pspec.name == 'fill-color':
+            return self._fill_color
+        elif pspec.name == 'stroke-color':
+            return self._stroke_color
+        elif pspec.name == 'progress-color':
+            return self._progress_color
+        elif pspec.name == 'percent':
+            return self._percent
+
+    def _int_to_rgb(self, int_color):
+        red = (int_color >> 24) & 0x000000FF
+        green = (int_color >> 16) & 0x000000FF
+        blue = (int_color >> 8) & 0x000000FF
+        alpha = int_color & 0x000000FF
+        return (red / 255.0, green / 255.0, blue / 255.0)
+
+    def do_paint_below_children(self, cr, damaged_box):
+        [width, height] = self.get_allocation()
+
+        line_width = 3.0
+        x = line_width
+        y = line_width
+        width -= line_width * 2
+        height -= line_width * 2
+
+        cr.move_to(x + self._radius, y);
+        cr.arc(x + width - self._radius, y + self._radius,
+               self._radius, math.pi * 1.5, math.pi * 2);
+        cr.arc(x + width - self._radius, x + height - self._radius,
+               self._radius, 0, math.pi * 0.5);
+        cr.arc(x + self._radius, y + height - self._radius,
+               self._radius, math.pi * 0.5, math.pi);
+        cr.arc(x + self._radius, y + self._radius, self._radius,
+               math.pi, math.pi * 1.5);
+
+        color = self._int_to_rgb(self._fill_color)
+        cr.set_source_rgb(*color)
+        cr.fill_preserve();
+
+        color = self._int_to_rgb(self._stroke_color)
+        cr.set_source_rgb(*color)
+        cr.set_line_width(line_width)
+        cr.stroke();
+
+        if self._percent > 0:
+            self._paint_progress_bar(cr, x, y, width, height, line_width)
+
+    def _paint_progress_bar(self, cr, x, y, width, height, line_width):
+        prog_x = x + line_width
+        prog_y = y + line_width
+        prog_width = (width - (line_width * 2)) * (self._percent / 100.0)
+        prog_height = (height - (line_width * 2))
+
+        x = prog_x
+        y = prog_y
+        width = prog_width
+        height = prog_height
+
+        cr.move_to(x + self._radius, y);
+        cr.arc(x + width - self._radius, y + self._radius,
+               self._radius, math.pi * 1.5, math.pi * 2);
+        cr.arc(x + width - self._radius, x + height - self._radius,
+               self._radius, 0, math.pi * 0.5);
+        cr.arc(x + self._radius, y + height - self._radius,
+               self._radius, math.pi * 0.5, math.pi);
+        cr.arc(x + self._radius, y + self._radius, self._radius,
+               math.pi, math.pi * 1.5);
+
+        color = self._int_to_rgb(self._progress_color)
+        cr.set_source_rgb(*color)
+        cr.fill_preserve();
diff --git a/services/nm/nmclient.py b/services/nm/nmclient.py
index 9d96a2a..055b4ba 100644
--- a/services/nm/nmclient.py
+++ b/services/nm/nmclient.py
@@ -40,15 +40,15 @@ IW_AUTH_ALG_SHARED_KEY  = 0x00000002
 
 
 NM_DEVICE_STAGE_STRINGS=("Unknown",
-	"Prepare",
-	"Config",
-	"Need Users Key",
-	"IP Config",
-	"IP Config Get",
-	"IP Config Commit",
-	"Activated",
-	"Failed",
-	"Cancled"
+    "Prepare",
+    "Config",
+    "Need Users Key",
+    "IP Config",
+    "IP Config Get",
+    "IP Config Commit",
+    "Activated",
+    "Failed",
+    "Cancled"
 )
 
 NM_SERVICE = 'org.freedesktop.NetworkManager'
@@ -70,278 +70,278 @@ sys_bus = dbus.SystemBus()
 
 
 class Network(gobject.GObject):
-	__gsignals__ = {
-		'init-failed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([]))
-	}
-
-	def __init__(self, op):
-		gobject.GObject.__init__(self)
-		self._op = op
-		self._ssid = None
-		self._mode = None
-		self._strength = 0
-		self._valid = False
-
-		obj = sys_bus.get_object(NM_SERVICE, self._op)
-		net = dbus.Interface(obj, NM_IFACE_DEVICES)
-		net.getProperties(reply_handler=self._update_reply_cb,
-				error_handler=self._update_error_cb)
-
-	def _update_reply_cb(self, *props):
-		self._ssid = props[1]
-		self._strength = props[3]
-		self._mode = props[6]
-		self._valid = True
-		logging.debug("Net(%s): ssid '%s', mode %d, strength %d" % (self._op,
-				self._ssid, self._mode, self._strength))
-
-	def _update_error_cb(self, err):
-		logging.debug("Net(%s): failed to update. (%s)" % (self._op, err))
-		self._valid = False
-		self.emit('init-failed')
-
-	def get_ssid(self):
-		return self._ssid
-
-	def get_op(self):
-		return self._op
-
-	def get_strength(self):
-		return self._strength
-
-	def set_strength(self, strength):
-		self._strength = strength
-
-	def is_valid(self):
-		return self._valid
-
-	def add_to_menu(self, menu, callback, dev):
-		strength = self._strength
-		if strength > 100:
-			strength = 100
-		elif strength < 0:
-			strength = 0
-		item = NetworkMenuItem(text=self._ssid, percent=strength)
-		item.connect('button-press-event', callback, (dev, self))
-		menu.add_item(item)
+    __gsignals__ = {
+        'init-failed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([]))
+    }
+
+    def __init__(self, op):
+        gobject.GObject.__init__(self)
+        self._op = op
+        self._ssid = None
+        self._mode = None
+        self._strength = 0
+        self._valid = False
+
+        obj = sys_bus.get_object(NM_SERVICE, self._op)
+        net = dbus.Interface(obj, NM_IFACE_DEVICES)
+        net.getProperties(reply_handler=self._update_reply_cb,
+                error_handler=self._update_error_cb)
+
+    def _update_reply_cb(self, *props):
+        self._ssid = props[1]
+        self._strength = props[3]
+        self._mode = props[6]
+        self._valid = True
+        logging.debug("Net(%s): ssid '%s', mode %d, strength %d" % (self._op,
+                self._ssid, self._mode, self._strength))
+
+    def _update_error_cb(self, err):
+        logging.debug("Net(%s): failed to update. (%s)" % (self._op, err))
+        self._valid = False
+        self.emit('init-failed')
+
+    def get_ssid(self):
+        return self._ssid
+
+    def get_op(self):
+        return self._op
+
+    def get_strength(self):
+        return self._strength
+
+    def set_strength(self, strength):
+        self._strength = strength
+
+    def is_valid(self):
+        return self._valid
+
+    def add_to_menu(self, menu, callback, dev):
+        strength = self._strength
+        if strength > 100:
+            strength = 100
+        elif strength < 0:
+            strength = 0
+        item = NetworkMenuItem(text=self._ssid, percent=strength)
+        item.connect('button-press-event', callback, (dev, self))
+        menu.add_item(item)
 
 
 class Device(gobject.GObject):
-	__gsignals__ = {
-		'init-failed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
-		'activated': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
-		'strength-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-							([gobject.TYPE_PYOBJECT]))
-	}
-
-	def __init__(self, op):
-		gobject.GObject.__init__(self)
-		self._op = op
-		self._iface = None
-		self._type = DEVICE_TYPE_UNKNOWN
-		self._udi = None
-		self._active = False
-		self._strength = 0
-		self._link = False
-		self._valid = False
-		self._networks = {}
-		self._active_net = None
-		self._caps = 0
-
-		obj = sys_bus.get_object(NM_SERVICE, self._op)
-		dev = dbus.Interface(obj, NM_IFACE_DEVICES)
-		dev.getProperties(reply_handler=self._update_reply_cb,
-				error_handler=self._update_error_cb)
-
-	def _update_reply_cb(self, *props):
-		self._iface = props[1]
-		self._type = props[2]
-		self._udi = props[3]
-		self._active = props[4]
-		if self._active:
-			self.emit('activated')
-		self._link = props[15]
-		self._caps = props[17]
-
-		if self._type == DEVICE_TYPE_802_11_WIRELESS:
-			old_strength = self._strength
-			self._strength = props[14]
-			if self._strength != old_strength:
-				self.emit('strength-changed', self._strength)
-			self._update_networks(props[20], props[19])
-
-		self._valid = True
-
-	def _update_networks(self, net_ops, active_op):
-		for op in net_ops:
-			net = Network(op)
-			self._networks[op] = net
-			net.connect('init-failed', self._net_init_failed)
-			if op == active_op:
-				self._active_net = op
-
-	def _update_error_cb(self, err):
-		logging.debug("Device(%s): failed to update. (%s)" % (self._op, err))
-		self._valid = False
-		self.emit('init-failed')
-
-	def _net_init_failed(self, net):
-		net_op = net.get_op()
-		if not self._networks.has_key(net_op):
-			return
-		if net_op == self._active_net:
-			self._active_net = None
-		del self._networks[net_op]
-
-	def _add_to_menu_wired(self, menu, callback):
-		item = NetworkMenuItem(_("Wired Network"), stylesheet="nm.Bubble.Wired",
-				hi_stylesheet="nm.Bubble.Wired.Hi",
-				act_stylesheet="nm.Bubble.Wired.Activated")
-		item.connect('button-press-event', callback, (self, None))
-		menu.add_item(item)
-
-	def _add_to_menu_wireless(self, menu, callback, active_only):
-		act_net = None
-		if self._active_net and self._networks.has_key(self._active_net):
-			act_net = self._networks[self._active_net]
-
-		# Only add the active network if active_only == True
-		if active_only:
-			if act_net:
-				act_net.add_to_menu(menu, callback, self)
-			return
-
-		# Otherwise, add all networks _except_ the active one
-		for net in self._networks.values():
-			if not net.is_valid():
-				continue
-			if act_net == net:
-				continue
-			net.add_to_menu(menu, callback, self)
-
-	def add_to_menu(self, menu, callback, active_only=False):
-		if self._type == DEVICE_TYPE_802_3_ETHERNET:
-			self._add_to_menu_wired(menu, callback)
-		elif self._type == DEVICE_TYPE_802_11_WIRELESS:
-			self._add_to_menu_wireless(menu, callback, active_only)
-
-	def get_op(self):
-		return self._op
-
-	def get_network(self, op):
-		if self._networks.has_key(op):
-			return self._networks[op]
-		return None
-
-	def get_network_ops(self):
-		return self._networks.keys()
-
-	def get_strength(self):
-		return self._strength
-
-	def set_strength(self, strength):
-		if strength == self._strength:
-			return False
-
-		if strength >= 0 and strength <= 100:
-			self._strength = strength
-		else:
-			self._strength = 0
-
-		self.emit('strength-changed', self._strength)
-
-	def network_appeared(self, network):
-		if self._networks.has_key(network):
-			return
-		net = Network(network)
-		self._networks[network] = net
-		net.connect('init-failed', self._net_init_failed)
-
-	def network_disappeared(self, network):
-		if not self._networks.has_key(network):
-			return
-		if network == self._active_net:
-			self._active_net = None
-		del self._networks[network]
-
-	def get_active(self):
-		return self._active
-
-	def set_active(self, active, ssid=None):
-		self._active = active
-		if self._type == DEVICE_TYPE_802_11_WIRELESS:
-			if not ssid:
-				self._active_net = None
-			else:
-				for (op, net) in self._networks.items():
-					if net.get_ssid() == ssid:
-						self._active_net = op
-
-	def get_type(self):
-		return self._type
-
-	def is_valid(self):
-		return self._valid
-
-	def set_carrier(self, on):
-		self._link = on
-
-	def get_capabilities(self):
-		return self._caps
+    __gsignals__ = {
+        'init-failed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
+        'activated': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ([])),
+        'strength-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                            ([gobject.TYPE_PYOBJECT]))
+    }
+
+    def __init__(self, op):
+        gobject.GObject.__init__(self)
+        self._op = op
+        self._iface = None
+        self._type = DEVICE_TYPE_UNKNOWN
+        self._udi = None
+        self._active = False
+        self._strength = 0
+        self._link = False
+        self._valid = False
+        self._networks = {}
+        self._active_net = None
+        self._caps = 0
+
+        obj = sys_bus.get_object(NM_SERVICE, self._op)
+        dev = dbus.Interface(obj, NM_IFACE_DEVICES)
+        dev.getProperties(reply_handler=self._update_reply_cb,
+                error_handler=self._update_error_cb)
+
+    def _update_reply_cb(self, *props):
+        self._iface = props[1]
+        self._type = props[2]
+        self._udi = props[3]
+        self._active = props[4]
+        if self._active:
+            self.emit('activated')
+        self._link = props[15]
+        self._caps = props[17]
+
+        if self._type == DEVICE_TYPE_802_11_WIRELESS:
+            old_strength = self._strength
+            self._strength = props[14]
+            if self._strength != old_strength:
+                self.emit('strength-changed', self._strength)
+            self._update_networks(props[20], props[19])
+
+        self._valid = True
+
+    def _update_networks(self, net_ops, active_op):
+        for op in net_ops:
+            net = Network(op)
+            self._networks[op] = net
+            net.connect('init-failed', self._net_init_failed)
+            if op == active_op:
+                self._active_net = op
+
+    def _update_error_cb(self, err):
+        logging.debug("Device(%s): failed to update. (%s)" % (self._op, err))
+        self._valid = False
+        self.emit('init-failed')
+
+    def _net_init_failed(self, net):
+        net_op = net.get_op()
+        if not self._networks.has_key(net_op):
+            return
+        if net_op == self._active_net:
+            self._active_net = None
+        del self._networks[net_op]
+
+    def _add_to_menu_wired(self, menu, callback):
+        item = NetworkMenuItem(_("Wired Network"), stylesheet="nm.Bubble.Wired",
+                hi_stylesheet="nm.Bubble.Wired.Hi",
+                act_stylesheet="nm.Bubble.Wired.Activated")
+        item.connect('button-press-event', callback, (self, None))
+        menu.add_item(item)
+
+    def _add_to_menu_wireless(self, menu, callback, active_only):
+        act_net = None
+        if self._active_net and self._networks.has_key(self._active_net):
+            act_net = self._networks[self._active_net]
+
+        # Only add the active network if active_only == True
+        if active_only:
+            if act_net:
+                act_net.add_to_menu(menu, callback, self)
+            return
+
+        # Otherwise, add all networks _except_ the active one
+        for net in self._networks.values():
+            if not net.is_valid():
+                continue
+            if act_net == net:
+                continue
+            net.add_to_menu(menu, callback, self)
+
+    def add_to_menu(self, menu, callback, active_only=False):
+        if self._type == DEVICE_TYPE_802_3_ETHERNET:
+            self._add_to_menu_wired(menu, callback)
+        elif self._type == DEVICE_TYPE_802_11_WIRELESS:
+            self._add_to_menu_wireless(menu, callback, active_only)
+
+    def get_op(self):
+        return self._op
+
+    def get_network(self, op):
+        if self._networks.has_key(op):
+            return self._networks[op]
+        return None
+
+    def get_network_ops(self):
+        return self._networks.keys()
+
+    def get_strength(self):
+        return self._strength
+
+    def set_strength(self, strength):
+        if strength == self._strength:
+            return False
+
+        if strength >= 0 and strength <= 100:
+            self._strength = strength
+        else:
+            self._strength = 0
+
+        self.emit('strength-changed', self._strength)
+
+    def network_appeared(self, network):
+        if self._networks.has_key(network):
+            return
+        net = Network(network)
+        self._networks[network] = net
+        net.connect('init-failed', self._net_init_failed)
+
+    def network_disappeared(self, network):
+        if not self._networks.has_key(network):
+            return
+        if network == self._active_net:
+            self._active_net = None
+        del self._networks[network]
+
+    def get_active(self):
+        return self._active
+
+    def set_active(self, active, ssid=None):
+        self._active = active
+        if self._type == DEVICE_TYPE_802_11_WIRELESS:
+            if not ssid:
+                self._active_net = None
+            else:
+                for (op, net) in self._networks.items():
+                    if net.get_ssid() == ssid:
+                        self._active_net = op
+
+    def get_type(self):
+        return self._type
+
+    def is_valid(self):
+        return self._valid
+
+    def set_carrier(self, on):
+        self._link = on
+
+    def get_capabilities(self):
+        return self._caps
 
 nm_bubble_wireless = {
-	'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
 }
 
 nm_bubble_wireless_hi = {
-	'fill-color'	 : 0x979797FF,
-	'stroke-color'	 : 0x979797FF,
-	'progress-color': 0x666666FF,
-	'spacing'		 : style.space_unit,
-	'padding'		 : style.space_unit * 1.5
+    'fill-color'     : 0x979797FF,
+    'stroke-color'     : 0x979797FF,
+    'progress-color': 0x666666FF,
+    'spacing'         : style.space_unit,
+    'padding'         : style.space_unit * 1.5
 }
 
 nm_bubble_wireless_activated = {
-	'fill-color'	 : 0xA7A7A7FF,
-	'stroke-color'	 : 0xA7A7A7FF,
-	'progress-color': 0x777777FF,
-	'spacing'		 : style.space_unit,
-	'padding'		 : style.space_unit * 1.5
+    'fill-color'     : 0xA7A7A7FF,
+    'stroke-color'     : 0xA7A7A7FF,
+    'progress-color': 0x777777FF,
+    'spacing'         : style.space_unit,
+    'padding'         : style.space_unit * 1.5
 }
 
 nm_bubble_wired = {
-	'fill-color'	 : 0x000000FF,
-	'stroke-color'	 : 0x000000FF,
-	'progress-color': 0x000000FF,
-	'spacing'		 : style.space_unit,
-	'padding'		 : style.space_unit * 1.5
+    'fill-color'     : 0x000000FF,
+    'stroke-color'     : 0x000000FF,
+    'progress-color': 0x000000FF,
+    'spacing'         : style.space_unit,
+    'padding'         : style.space_unit * 1.5
 }
 
 nm_bubble_wired_hi = {
-	'fill-color'	 : 0x333333FF,
-	'stroke-color'	 : 0x333333FF,
-	'progress-color': 0x000000FF,
-	'spacing'		 : style.space_unit,
-	'padding'		 : style.space_unit * 1.5
+    'fill-color'     : 0x333333FF,
+    'stroke-color'     : 0x333333FF,
+    'progress-color': 0x000000FF,
+    'spacing'         : style.space_unit,
+    'padding'         : style.space_unit * 1.5
 }
 
 nm_bubble_wired_activated = {
-	'fill-color'	 : 0x444444FF,
-	'stroke-color'	 : 0x444444FF,
-	'progress-color': 0x000000FF,
-	'spacing'		 : style.space_unit,
-	'padding'		 : style.space_unit * 1.5
+    'fill-color'     : 0x444444FF,
+    'stroke-color'     : 0x444444FF,
+    'progress-color': 0x000000FF,
+    'spacing'         : style.space_unit,
+    'padding'         : style.space_unit * 1.5
 }
 
 nm_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)
 }
 
 
@@ -354,63 +354,63 @@ style.register_stylesheet("nm.Bubble.Wired.Activated", nm_bubble_wired_activated
 style.register_stylesheet("nm.MenuItem.Title", nm_menu_item_title)
 
 class NetworkMenuItem(Bubble):
-	def __init__(self, text, percent=0, stylesheet="nm.Bubble.Wireless",
-				hi_stylesheet="nm.Bubble.Wireless.Hi",
-				act_stylesheet="nm.Bubble.Wireless.Activated"):
-		Bubble.__init__(self, percent=percent)
-		self._hover = False
-		self._default_stylesheet = stylesheet
-		self._hi_stylesheet = hi_stylesheet
-		self._act_stylesheet = act_stylesheet
-		style.apply_stylesheet(self, stylesheet)
-
-		text_item = hippo.CanvasText(text=text)
-		style.apply_stylesheet(text_item, 'nm.MenuItem.Title')
-		self.append(text_item)
-
-		self.connect('motion-notify-event', self._motion_notify_event_cb)
-		# Disable active hilight for now...
-		#self.connect('button-press-event', self._button_press_event_cb)
-
-	def _motion_notify_event_cb(self, widget, event):
-		if event.detail == hippo.MOTION_DETAIL_ENTER:
-			if not self._hover:
-				self._hover = True
-				style.apply_stylesheet(self, self._hi_stylesheet)
-		elif event.detail == hippo.MOTION_DETAIL_LEAVE:
-			if self._hover:
-				self._hover = False
-				style.apply_stylesheet(self, self._default_stylesheet)
-		return True
-
-	def _button_press_event_cb(self, widget, event):
-		style.apply_stylesheet(self, self._act_stylesheet)
-		return False
+    def __init__(self, text, percent=0, stylesheet="nm.Bubble.Wireless",
+                hi_stylesheet="nm.Bubble.Wireless.Hi",
+                act_stylesheet="nm.Bubble.Wireless.Activated"):
+        Bubble.__init__(self, percent=percent)
+        self._hover = False
+        self._default_stylesheet = stylesheet
+        self._hi_stylesheet = hi_stylesheet
+        self._act_stylesheet = act_stylesheet
+        style.apply_stylesheet(self, stylesheet)
+
+        text_item = hippo.CanvasText(text=text)
+        style.apply_stylesheet(text_item, 'nm.MenuItem.Title')
+        self.append(text_item)
+
+        self.connect('motion-notify-event', self._motion_notify_event_cb)
+        # Disable active hilight for now...
+        #self.connect('button-press-event', self._button_press_event_cb)
+
+    def _motion_notify_event_cb(self, widget, event):
+        if event.detail == hippo.MOTION_DETAIL_ENTER:
+            if not self._hover:
+                self._hover = True
+                style.apply_stylesheet(self, self._hi_stylesheet)
+        elif event.detail == hippo.MOTION_DETAIL_LEAVE:
+            if self._hover:
+                self._hover = False
+                style.apply_stylesheet(self, self._default_stylesheet)
+        return True
+
+    def _button_press_event_cb(self, widget, event):
+        style.apply_stylesheet(self, self._act_stylesheet)
+        return False
 
 class NetworkMenu(gtk.Window):
-	__gsignals__ = {
-		'action': (gobject.SIGNAL_RUN_FIRST,
-				   gobject.TYPE_NONE, ([int])),
-	}
+    __gsignals__ = {
+        'action': (gobject.SIGNAL_RUN_FIRST,
+                   gobject.TYPE_NONE, ([int])),
+    }
 
-	def __init__(self):
-		gtk.Window.__init__(self, gtk.WINDOW_POPUP)
+    def __init__(self):
+        gtk.Window.__init__(self, gtk.WINDOW_POPUP)
 
-		canvas = hippo.Canvas()
-		self.add(canvas)
-		canvas.show()
+        canvas = hippo.Canvas()
+        self.add(canvas)
+        canvas.show()
 
-		self._root = hippo.CanvasBox()
-		style.apply_stylesheet(self._root, 'menu')
-		canvas.set_root(self._root)
+        self._root = hippo.CanvasBox()
+        style.apply_stylesheet(self._root, 'menu')
+        canvas.set_root(self._root)
 
-	def add_separator(self):
-		separator = hippo.CanvasBox()
-		style.apply_stylesheet(separator, 'menu.Separator')
-		self._root.append(separator)
+    def add_separator(self):
+        separator = hippo.CanvasBox()
+        style.apply_stylesheet(separator, 'menu.Separator')
+        self._root.append(separator)
 
-	def add_item(self, item):
-		self._root.append(item)
+    def add_item(self, item):
+        self._root.append(item)
 
 
 
@@ -429,488 +429,488 @@ ICON_WIRELESS_61_80 = "stock-net-wireless-61-80"
 ICON_WIRELESS_81_100 = "stock-net-wireless-81-100"
 
 class NMClientApp:
-	def __init__(self):
-		self.nminfo = None
-		self._nm_present = False
-		self._nm_state = NM_STATE_UNKNOWN
-		self._update_timer = 0
-		self._active_device = None
-		self._devices = {}
-		self._key_dialog = None
-
-		self._icon_theme = gtk.icon_theme_get_default()
-		self._icons = {}
-		self._cur_icon = None
-		try:
-			self._icons = self._load_icons()
-		except RuntimeError:
-			logging.debug("Couldn't find required icon resources, will exit.")
-			os._exit(1)
-		self._setup_trayicon()
-
-		self._menu = None
-		self._hover_menu = False
-		self._timeline = Timeline(self)
-		self._timeline.add_tag('popup', 6, 6)
-		self._timeline.add_tag('before_popdown', 7, 7)
-		self._timeline.add_tag('popdown', 8, 8)
-
-		try:
-			self.nminfo = nminfo.NMInfo(self)
-		except RuntimeError:
-			pass
-		self._setup_dbus()
-		if self._nm_present:
-			self._get_nm_state()
-			self._get_initial_devices()
-
-	def _get_one_icon_pixbuf(self, name):
-		info = self._icon_theme.lookup_icon(name, 75, 0)
-		if not info or not info.get_filename():
-			raise RuntimeError
-		return gtk.gdk.pixbuf_new_from_file(info.get_filename())
-
-	def _load_icons(self):
-		icons = {}
-		icons[ICON_WIRED] = self._get_one_icon_pixbuf(ICON_WIRED)
-		icons[ICON_WIRELESS_00] = self._get_one_icon_pixbuf(ICON_WIRELESS_00)
-		icons[ICON_WIRELESS_01_20] = self._get_one_icon_pixbuf(ICON_WIRELESS_01_20)
-		icons[ICON_WIRELESS_21_40] = self._get_one_icon_pixbuf(ICON_WIRELESS_21_40)
-		icons[ICON_WIRELESS_41_60] = self._get_one_icon_pixbuf(ICON_WIRELESS_41_60)
-		icons[ICON_WIRELESS_61_80] = self._get_one_icon_pixbuf(ICON_WIRELESS_61_80)
-		icons[ICON_WIRELESS_81_100] = self._get_one_icon_pixbuf(ICON_WIRELESS_81_100)
-		return icons
-
-	def _get_nm_state(self):
-		# Grab NM's state
-		self._nm_obj.state(reply_handler=self._get_state_reply_cb, \
-				error_handler=self._get_state_error_cb)
-
-	def _get_state_reply_cb(self, state):
-		if self._nm_state != state:
-			self._schedule_icon_update(immediate=True)
-		self._nm_state = state
-
-	def _get_state_error_cb(self, err):
-		logging.debug("Failed to get NetworkManager state! %s" % err)
-
-	def _get_icon(self):
-		act_dev = None
-		if self._active_device and self._devices.has_key(self._active_device):
-			act_dev = self._devices[self._active_device]
-
-		pixbuf = None
-		if not self._nm_present \
-				or not act_dev \
-				or self._nm_state == NM_STATE_UNKNOWN \
-				or self._nm_state == NM_STATE_ASLEEP \
-				or self._nm_state == NM_STATE_DISCONNECTED:
-			pixbuf = self._icons[ICON_WIRELESS_00]
-		elif act_dev.get_type() == DEVICE_TYPE_802_3_ETHERNET:
-			pixbuf = self._icons[ICON_WIRED]
-		elif act_dev.get_type() == DEVICE_TYPE_802_11_WIRELESS:
-			strength = act_dev.get_strength()
-			if strength <= 0:
-				pixbuf = self._icons[ICON_WIRELESS_00]
-			elif strength >= 1 and strength <= 20:
-				pixbuf = self._icons[ICON_WIRELESS_01_20]
-			elif strength >= 21 and strength <= 40:
-				pixbuf = self._icons[ICON_WIRELESS_21_40]
-			elif strength >= 41 and strength <= 60:
-				pixbuf = self._icons[ICON_WIRELESS_41_60]
-			elif strength >= 61 and strength <= 80:
-				pixbuf = self._icons[ICON_WIRELESS_61_80]
-			elif strength >= 81 and strength:
-				pixbuf = self._icons[ICON_WIRELESS_81_100]
-
-		if not pixbuf:
-			pixbuf = self._icons[ICON_WIRELESS_00]
-		return pixbuf
-
-	def _setup_trayicon(self):
-		pixbuf = self._get_icon()
-		self._trayicon = gtk.status_icon_new_from_pixbuf(pixbuf)
-		self._trayicon.connect("popup_menu", self._status_icon_clicked)
-		self._trayicon.connect("activate", self._status_icon_clicked)
-		self._schedule_icon_update()
-
-	def _status_icon_clicked(self, button=0, time=None):
-		self._timeline.play(None, 'popup')
-
-	def _get_menu_position(self, menu, item):
-		(screen, rect, orientation) = item.get_geometry()
-		[item_x, item_y, item_w, item_h] = rect
-		[menu_w, menu_h] = menu.size_request()
-
-		x = item_x + item_w - menu_w
-		y = item_y + item_h
-
-		x = min(x, screen.get_width() - menu_w)
-		x = max(0, x)
-
-		y = min(y, screen.get_height() - menu_h)
-		y = max(0, y)
-
-		return (x, y)
-
-	def do_popup(self, current, n_frames):
-		if self._menu:
-			return
-
-		self._menu = self._create_menu()
-		self._menu.connect('enter-notify-event',
-						   self._menu_enter_notify_event_cb)
-		self._menu.connect('leave-notify-event',
-						   self._menu_leave_notify_event_cb)
-		(x, y) = self._get_menu_position(self._menu, self._trayicon)
-		self._menu.move(x, y)
-		self._menu.show_all()
-
-	def do_popdown(self, current, frame):
-		if self._menu:
-			self._menu.destroy()
-			self._menu = None
-
-	def _popdown(self):
-		self._timeline.play('popdown', 'popdown')
-
-	def _menu_enter_notify_event_cb(self, widget, event):
-		self._hover_menu = True
-		self._timeline.play('popup', 'popup')
-
-	def _menu_leave_notify_event_cb(self, widget, event):
-		self._hover_menu = False
-		self._popdown()
-
-	def _create_menu(self):
-		menu = NetworkMenu()
-
-		# Active device goes above the separator
-		act_dev = None
-		if self._active_device and self._devices.has_key(self._active_device):
-			act_dev = self._devices[self._active_device]
-
-		if act_dev:
-			act_dev.add_to_menu(menu, self._menu_item_clicked_cb, active_only=True)
-			menu.add_separator()
-			
-		# Wired devices first, if they don't support carrier detect
-		for dev in self._devices.values():
-			if not dev.is_valid():
-				continue
-			if dev.get_type() != DEVICE_TYPE_802_3_ETHERNET:
-				continue
-			if dev.get_capabilities() & NM_DEVICE_CAP_CARRIER_DETECT:
-				continue
-			if dev == act_dev:
-				continue
-			dev.add_to_menu(menu, self._menu_item_clicked_cb)
-
-		# Wireless devices second
-		for dev in self._devices.values():
-			if not dev.is_valid():
-				continue
-			if dev.get_type() != DEVICE_TYPE_802_11_WIRELESS:
-				continue
-			dev.add_to_menu(menu, self._menu_item_clicked_cb)
-
-		return menu
-
-	def _update_icon(self):
-		pixbuf = self._get_icon()
-		if self._cur_icon != pixbuf:
-			self._trayicon.set_from_pixbuf(pixbuf)
-			self._cur_icon = pixbuf
-
-		blink = False
-		if self._nm_state == NM_STATE_CONNECTING:
-			blink = True
-		self._trayicon.set_blinking(blink)
-
-		self._update_timer = 0
-		return False
-
-	def _schedule_icon_update(self, immediate=False):
-		if immediate and self._update_timer:
-			gobject.source_remove(self._update_timer)
-			self._update_timer = 0
-
-		if self._update_timer != 0:
-			# There is already an update scheduled
-			return
-
-		if immediate:
-			self._update_timer = gobject.idle_add(self._update_icon)
-		else:
-			self._update_timer = gobject.timeout_add(2000, self._update_icon)
-
-	def _get_initial_devices_reply_cb(self, ops):
-		for op in ops:
-			self._add_device(op)
-
-	def _dev_init_failed_cb(self, dev):
-		# Device failed to initialize, likely due to dbus errors or something
-		op = dev.get_op()
-		self._remove_device(op)
-
-	def _get_initial_devices_error_cb(self, err):
-		logging.debug("Error updating devices (%s)" % err)
-
-	def _get_initial_devices(self):
-		self._nm_obj.getDevices(reply_handler=self._get_initial_devices_reply_cb, \
-				error_handler=self._get_initial_devices_error_cb)
-
-	def _add_device(self, dev_op):
-		if self._devices.has_key(dev_op):
-			return
-		dev = Device(dev_op)
-		self._devices[dev_op] = dev
-		dev.connect('init-failed', self._dev_init_failed_cb)
-		dev.connect('activated', self._dev_activated_cb)
-		dev.connect('strength-changed', self._dev_strength_changed_cb)
-
-	def _remove_device(self, dev_op):
-		if not self._devices.has_key(dev_op):
-			return
-		if self._active_device == dev_op:
-			self._active_device = None
-		dev = self._devices[dev_op]
-		dev.disconnect('activated')
-		dev.disconnect('init-failed')
-		dev.disconnect('strength-changed')
-		del self._devices[dev_op]
-		self._schedule_icon_update(immediate=True)
-
-	def _dev_activated_cb(self, dev):
-		op = dev.get_op()
-		if not self._devices.has_key(op):
-			return
-		if not dev.get_active():
-			return
-		self._active_device = op
-		self._schedule_icon_update(immediate=True)
-
-	def _dev_strength_changed_cb(self, dev, strength):
-		op = dev.get_op()
-		if not self._devices.has_key(op):
-			return
-		if not dev.get_active():
-			return
-		self._schedule_icon_update()
-
-	def get_device(self, dev_op):
-		if not self._devices.has_key(dev_op):
-			return None
-		return self._devices[dev_op]
-
-	def _setup_dbus(self):
-		self._sig_handlers = {
-			'StateChange': self.state_change_sig_handler,
-			'DeviceAdded': self.device_added_sig_handler,
-			'DeviceRemoved': self.device_removed_sig_handler,
-			'DeviceActivationStage': self.device_activation_stage_sig_handler,
-			'DeviceActivating': self.device_activating_sig_handler,
-			'DeviceNowActive': self.device_now_active_sig_handler,
-			'DeviceNoLongerActive': self.device_no_longer_active_sig_handler,
-			'DeviceCarrierOn': self.device_carrier_on_sig_handler,
-			'DeviceCarrierOff': self.device_carrier_off_sig_handler,
-			'DeviceStrengthChanged': self.wireless_device_strength_changed_sig_handler,
-			'WirelessNetworkAppeared': self.wireless_network_appeared_sig_handler,
-			'WirelessNetworkDisappeared': self.wireless_network_disappeared_sig_handler,
-			'WirelessNetworkStrengthChanged': self.wireless_network_strength_changed_sig_handler
-		}
-
-		self._nm_proxy = sys_bus.get_object(NM_SERVICE, NM_PATH)
-		self._nm_obj = dbus.Interface(self._nm_proxy, NM_IFACE)
-
-		sys_bus.add_signal_receiver(self.name_owner_changed_sig_handler,
-										 signal_name="NameOwnerChanged",
-										 dbus_interface="org.freedesktop.DBus")
-
-		sys_bus.add_signal_receiver(self.catchall_signal_handler,
-										 dbus_interface=NM_IFACE) 
-
-		sys_bus.add_signal_receiver(self.catchall_signal_handler,
-										 dbus_interface=NM_IFACE + 'Devices')
-
-		for (signal, handler) in self._sig_handlers.items():
-			sys_bus.add_signal_receiver(handler, signal_name=signal, dbus_interface=NM_IFACE)
-
-		# Find out whether or not NM is running
-		try:
-			bus_object = sys_bus.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus')
-			name = bus_object.GetNameOwner("org.freedesktop.NetworkManagerInfo", \
-					dbus_interface='org.freedesktop.DBus')
-			if name:
-				self._nm_present = True
-		except dbus.DBusException:
-			pass
-
-	@dbus.decorators.explicitly_pass_message
-	def catchall_signal_handler(self, *args, **keywords):
-		dbus_message = keywords['dbus_message']
-		mem = dbus_message.get_member()
-		iface = dbus_message.get_interface()
-
-		if iface == NM_IFACE and mem in self._sig_handlers.keys():
-			return
-
-	 	logging.debug('Caught signal %s.%s' % (dbus_message.get_interface(), mem))
-		for arg in args:
-			logging.debug('        ' + str(arg))
-
-	def _menu_item_clicked_cb(self, widget, event, dev_data):
-		(device, network) = dev_data
-		net_op = ""
-		if network:
-			net_op = network.get_op()
-		try:
-			# NM 0.6.4 and earlier have a bug which returns an
-			# InvalidArguments error if no security information is passed
-			# for wireless networks
-			self._nm_obj.setActiveDevice(device.get_op(), network.get_ssid())
-		except dbus.DBusException, e:
-			if str(e).find("invalid arguments"):
-				pass
-			else:
-				raise dbus.DBusException(e)
-
-		self._popdown()
-
-	def get_key_for_network(self, net, async_cb, async_err_cb):
-		# Throw up a dialog asking for the key here, and set
-		# the authentication algorithm to the given one, if any
-		#
-		# Key needs to be limited to _either_ 10 or 26 digits long,
-		# and contain _only_ _hex_ digits, 0-9 or a-f
-		#
-		# Auth algorithm should be a dropdown of: [Open System, Shared Key],
-		# mapping to the values [IW_AUTH_ALG_OPEN_SYSTEM, IW_AUTH_ALG_SHARED_KEY]
-		# above
-
-		self._key_dialog = WEPKeyDialog(net, async_cb, async_err_cb)
-		self._key_dialog.connect("response", self._key_dialog_response_cb)
-		self._key_dialog.connect("destroy", self._key_dialog_destroy_cb)
-		self._key_dialog.show_all()
-
-	def _key_dialog_destroy_cb(self, widget, foo=None):
-		if widget != self._key_dialog:
-			return
-		self._key_dialog_response_cb(widget, gtk.RESPONSE_CANCEL)
-
-	def _key_dialog_response_cb(self, widget, response_id):
-		if widget != self._key_dialog:
-			return
-		key = self._key_dialog.get_key()
-		wep_auth_alg = self._key_dialog.get_auth_alg()
-		net = self._key_dialog.get_network()
-		(async_cb, async_err_cb) = self._key_dialog.get_callbacks()
-
-		# Clear self._key_dialog before we call destroy(), otherwise
-		# the destroy will trigger and we'll get called again by
-		# self._key_dialog_destroy_cb
-		self._key_dialog = None
-		widget.destroy()
-
-		if response_id == gtk.RESPONSE_OK:
-			self.nminfo.get_key_for_network_cb(
-					net, key, wep_auth_alg, async_cb, async_err_cb, canceled=False)
-		else:
-			self.nminfo.get_key_for_network_cb(
-					net, None, None, async_cb, async_err_cb, canceled=True)
-
-	def cancel_get_key_for_network(self):
-		# Close the wireless key dialog and just have it return
-		# with the 'canceled' argument set to true
-		if not self._key_dialog:
-			return
-		self._key_dialog_destroy_cb(self._key_dialog)
-
-	def device_activation_stage_sig_handler(self, device, stage):
-		logging.debug('Device Activation Stage "%s" for device %s' % (NM_DEVICE_STAGE_STRINGS[stage], device))
-
-	def state_change_sig_handler(self, state):
-		self._nm_state = state
-		self._schedule_icon_update(immediate=True)
-
-	def device_activating_sig_handler(self, device):
-		self._active_device = device
-
-	def device_now_active_sig_handler(self, device, ssid=None):
-		if not self._devices.has_key(device):
-			return
-		self._active_device = device
-		self._devices[device].set_active(True, ssid)
-		self._schedule_icon_update(immediate=True)
-
-	def device_no_longer_active_sig_handler(self, device):
-		if not self._devices.has_key(device):
-			return
-		if self._active_device == device:
-			self._active_device = None
-		self._devices[device].set_active(False)
-		self._schedule_icon_update(immediate=True)
-
-	def name_owner_changed_sig_handler(self, name, old, new):
-		if name != NM_SERVICE:
-			return
-		if (old and len(old)) and (not new and not len(new)):
-			# NM went away
-			self._nm_present = False
-			self._schedule_icon_update(immediate=True)
-			for op in self._devices.keys():
-				del self._devices[op]
-			self._devices = {}
-			self._active_device = None
-			self._nm_state = NM_STATE_UNKNOWN
-		elif (not old and not len(old)) and (new and len(new)):
-			# NM started up
-			self._nm_present = True
-			self._get_nm_state()
-			self._get_initial_devices()
-
-	def device_added_sig_handler(self, device):
-		self._add_device(device)
-
-	def device_removed_sig_handler(self, device):
-		self._remove_device(device)
-
-	def wireless_network_appeared_sig_handler(self, device, network):
-		if not self._devices.has_key(device):
-			return
-		self._devices[device].network_appeared(network)
-
-	def wireless_network_disappeared_sig_handler(self, device, network):
-		if not self._devices.has_key(device):
-			return
-		self._devices[device].network_disappeared(network)
-
-	def wireless_device_strength_changed_sig_handler(self, device, strength):
-		if not self._devices.has_key(device):
-			return
-		self._devices[device].set_strength(strength)
-
-	def wireless_network_strength_changed_sig_handler(self, device, network, strength):
-		if not self._devices.has_key(device):
-			return
-		net = self._devices[device].get_network(network)
-		if net:
-			net.set_strength(strength)
-
-	def device_carrier_on_sig_handler(self, device):
-		if not self._devices.has_key(device):
-			return
-		self._devices[device].set_carrier(True)
-
-	def device_carrier_off_sig_handler(self, device):
-		if not self._devices.has_key(device):
-			return
-		self._devices[device].set_carrier(False)
-
-	def run(self):
-		loop = gobject.MainLoop()
-		try:
-			loop.run()
-		except KeyboardInterrupt:
-			pass
+    def __init__(self):
+        self.nminfo = None
+        self._nm_present = False
+        self._nm_state = NM_STATE_UNKNOWN
+        self._update_timer = 0
+        self._active_device = None
+        self._devices = {}
+        self._key_dialog = None
+
+        self._icon_theme = gtk.icon_theme_get_default()
+        self._icons = {}
+        self._cur_icon = None
+        try:
+            self._icons = self._load_icons()
+        except RuntimeError:
+            logging.debug("Couldn't find required icon resources, will exit.")
+            os._exit(1)
+        self._setup_trayicon()
+
+        self._menu = None
+        self._hover_menu = False
+        self._timeline = Timeline(self)
+        self._timeline.add_tag('popup', 6, 6)
+        self._timeline.add_tag('before_popdown', 7, 7)
+        self._timeline.add_tag('popdown', 8, 8)
+
+        try:
+            self.nminfo = nminfo.NMInfo(self)
+        except RuntimeError:
+            pass
+        self._setup_dbus()
+        if self._nm_present:
+            self._get_nm_state()
+            self._get_initial_devices()
+
+    def _get_one_icon_pixbuf(self, name):
+        info = self._icon_theme.lookup_icon(name, 75, 0)
+        if not info or not info.get_filename():
+            raise RuntimeError
+        return gtk.gdk.pixbuf_new_from_file(info.get_filename())
+
+    def _load_icons(self):
+        icons = {}
+        icons[ICON_WIRED] = self._get_one_icon_pixbuf(ICON_WIRED)
+        icons[ICON_WIRELESS_00] = self._get_one_icon_pixbuf(ICON_WIRELESS_00)
+        icons[ICON_WIRELESS_01_20] = self._get_one_icon_pixbuf(ICON_WIRELESS_01_20)
+        icons[ICON_WIRELESS_21_40] = self._get_one_icon_pixbuf(ICON_WIRELESS_21_40)
+        icons[ICON_WIRELESS_41_60] = self._get_one_icon_pixbuf(ICON_WIRELESS_41_60)
+        icons[ICON_WIRELESS_61_80] = self._get_one_icon_pixbuf(ICON_WIRELESS_61_80)
+        icons[ICON_WIRELESS_81_100] = self._get_one_icon_pixbuf(ICON_WIRELESS_81_100)
+        return icons
+
+    def _get_nm_state(self):
+        # Grab NM's state
+        self._nm_obj.state(reply_handler=self._get_state_reply_cb, \
+                error_handler=self._get_state_error_cb)
+
+    def _get_state_reply_cb(self, state):
+        if self._nm_state != state:
+            self._schedule_icon_update(immediate=True)
+        self._nm_state = state
+
+    def _get_state_error_cb(self, err):
+        logging.debug("Failed to get NetworkManager state! %s" % err)
+
+    def _get_icon(self):
+        act_dev = None
+        if self._active_device and self._devices.has_key(self._active_device):
+            act_dev = self._devices[self._active_device]
+
+        pixbuf = None
+        if not self._nm_present \
+                or not act_dev \
+                or self._nm_state == NM_STATE_UNKNOWN \
+                or self._nm_state == NM_STATE_ASLEEP \
+                or self._nm_state == NM_STATE_DISCONNECTED:
+            pixbuf = self._icons[ICON_WIRELESS_00]
+        elif act_dev.get_type() == DEVICE_TYPE_802_3_ETHERNET:
+            pixbuf = self._icons[ICON_WIRED]
+        elif act_dev.get_type() == DEVICE_TYPE_802_11_WIRELESS:
+            strength = act_dev.get_strength()
+            if strength <= 0:
+                pixbuf = self._icons[ICON_WIRELESS_00]
+            elif strength >= 1 and strength <= 20:
+                pixbuf = self._icons[ICON_WIRELESS_01_20]
+            elif strength >= 21 and strength <= 40:
+                pixbuf = self._icons[ICON_WIRELESS_21_40]
+            elif strength >= 41 and strength <= 60:
+                pixbuf = self._icons[ICON_WIRELESS_41_60]
+            elif strength >= 61 and strength <= 80:
+                pixbuf = self._icons[ICON_WIRELESS_61_80]
+            elif strength >= 81 and strength:
+                pixbuf = self._icons[ICON_WIRELESS_81_100]
+
+        if not pixbuf:
+            pixbuf = self._icons[ICON_WIRELESS_00]
+        return pixbuf
+
+    def _setup_trayicon(self):
+        pixbuf = self._get_icon()
+        self._trayicon = gtk.status_icon_new_from_pixbuf(pixbuf)
+        self._trayicon.connect("popup_menu", self._status_icon_clicked)
+        self._trayicon.connect("activate", self._status_icon_clicked)
+        self._schedule_icon_update()
+
+    def _status_icon_clicked(self, button=0, time=None):
+        self._timeline.play(None, 'popup')
+
+    def _get_menu_position(self, menu, item):
+        (screen, rect, orientation) = item.get_geometry()
+        [item_x, item_y, item_w, item_h] = rect
+        [menu_w, menu_h] = menu.size_request()
+
+        x = item_x + item_w - menu_w
+        y = item_y + item_h
+
+        x = min(x, screen.get_width() - menu_w)
+        x = max(0, x)
+
+        y = min(y, screen.get_height() - menu_h)
+        y = max(0, y)
+
+        return (x, y)
+
+    def do_popup(self, current, n_frames):
+        if self._menu:
+            return
+
+        self._menu = self._create_menu()
+        self._menu.connect('enter-notify-event',
+                           self._menu_enter_notify_event_cb)
+        self._menu.connect('leave-notify-event',
+                           self._menu_leave_notify_event_cb)
+        (x, y) = self._get_menu_position(self._menu, self._trayicon)
+        self._menu.move(x, y)
+        self._menu.show_all()
+
+    def do_popdown(self, current, frame):
+        if self._menu:
+            self._menu.destroy()
+            self._menu = None
+
+    def _popdown(self):
+        self._timeline.play('popdown', 'popdown')
+
+    def _menu_enter_notify_event_cb(self, widget, event):
+        self._hover_menu = True
+        self._timeline.play('popup', 'popup')
+
+    def _menu_leave_notify_event_cb(self, widget, event):
+        self._hover_menu = False
+        self._popdown()
+
+    def _create_menu(self):
+        menu = NetworkMenu()
+
+        # Active device goes above the separator
+        act_dev = None
+        if self._active_device and self._devices.has_key(self._active_device):
+            act_dev = self._devices[self._active_device]
+
+        if act_dev:
+            act_dev.add_to_menu(menu, self._menu_item_clicked_cb, active_only=True)
+            menu.add_separator()
+            
+        # Wired devices first, if they don't support carrier detect
+        for dev in self._devices.values():
+            if not dev.is_valid():
+                continue
+            if dev.get_type() != DEVICE_TYPE_802_3_ETHERNET:
+                continue
+            if dev.get_capabilities() & NM_DEVICE_CAP_CARRIER_DETECT:
+                continue
+            if dev == act_dev:
+                continue
+            dev.add_to_menu(menu, self._menu_item_clicked_cb)
+
+        # Wireless devices second
+        for dev in self._devices.values():
+            if not dev.is_valid():
+                continue
+            if dev.get_type() != DEVICE_TYPE_802_11_WIRELESS:
+                continue
+            dev.add_to_menu(menu, self._menu_item_clicked_cb)
+
+        return menu
+
+    def _update_icon(self):
+        pixbuf = self._get_icon()
+        if self._cur_icon != pixbuf:
+            self._trayicon.set_from_pixbuf(pixbuf)
+            self._cur_icon = pixbuf
+
+        blink = False
+        if self._nm_state == NM_STATE_CONNECTING:
+            blink = True
+        self._trayicon.set_blinking(blink)
+
+        self._update_timer = 0
+        return False
+
+    def _schedule_icon_update(self, immediate=False):
+        if immediate and self._update_timer:
+            gobject.source_remove(self._update_timer)
+            self._update_timer = 0
+
+        if self._update_timer != 0:
+            # There is already an update scheduled
+            return
+
+        if immediate:
+            self._update_timer = gobject.idle_add(self._update_icon)
+        else:
+            self._update_timer = gobject.timeout_add(2000, self._update_icon)
+
+    def _get_initial_devices_reply_cb(self, ops):
+        for op in ops:
+            self._add_device(op)
+
+    def _dev_init_failed_cb(self, dev):
+        # Device failed to initialize, likely due to dbus errors or something
+        op = dev.get_op()
+        self._remove_device(op)
+
+    def _get_initial_devices_error_cb(self, err):
+        logging.debug("Error updating devices (%s)" % err)
+
+    def _get_initial_devices(self):
+        self._nm_obj.getDevices(reply_handler=self._get_initial_devices_reply_cb, \
+                error_handler=self._get_initial_devices_error_cb)
+
+    def _add_device(self, dev_op):
+        if self._devices.has_key(dev_op):
+            return
+        dev = Device(dev_op)
+        self._devices[dev_op] = dev
+        dev.connect('init-failed', self._dev_init_failed_cb)
+        dev.connect('activated', self._dev_activated_cb)
+        dev.connect('strength-changed', self._dev_strength_changed_cb)
+
+    def _remove_device(self, dev_op):
+        if not self._devices.has_key(dev_op):
+            return
+        if self._active_device == dev_op:
+            self._active_device = None
+        dev = self._devices[dev_op]
+        dev.disconnect('activated')
+        dev.disconnect('init-failed')
+        dev.disconnect('strength-changed')
+        del self._devices[dev_op]
+        self._schedule_icon_update(immediate=True)
+
+    def _dev_activated_cb(self, dev):
+        op = dev.get_op()
+        if not self._devices.has_key(op):
+            return
+        if not dev.get_active():
+            return
+        self._active_device = op
+        self._schedule_icon_update(immediate=True)
+
+    def _dev_strength_changed_cb(self, dev, strength):
+        op = dev.get_op()
+        if not self._devices.has_key(op):
+            return
+        if not dev.get_active():
+            return
+        self._schedule_icon_update()
+
+    def get_device(self, dev_op):
+        if not self._devices.has_key(dev_op):
+            return None
+        return self._devices[dev_op]
+
+    def _setup_dbus(self):
+        self._sig_handlers = {
+            'StateChange': self.state_change_sig_handler,
+            'DeviceAdded': self.device_added_sig_handler,
+            'DeviceRemoved': self.device_removed_sig_handler,
+            'DeviceActivationStage': self.device_activation_stage_sig_handler,
+            'DeviceActivating': self.device_activating_sig_handler,
+            'DeviceNowActive': self.device_now_active_sig_handler,
+            'DeviceNoLongerActive': self.device_no_longer_active_sig_handler,
+            'DeviceCarrierOn': self.device_carrier_on_sig_handler,
+            'DeviceCarrierOff': self.device_carrier_off_sig_handler,
+            'DeviceStrengthChanged': self.wireless_device_strength_changed_sig_handler,
+            'WirelessNetworkAppeared': self.wireless_network_appeared_sig_handler,
+            'WirelessNetworkDisappeared': self.wireless_network_disappeared_sig_handler,
+            'WirelessNetworkStrengthChanged': self.wireless_network_strength_changed_sig_handler
+        }
+
+        self._nm_proxy = sys_bus.get_object(NM_SERVICE, NM_PATH)
+        self._nm_obj = dbus.Interface(self._nm_proxy, NM_IFACE)
+
+        sys_bus.add_signal_receiver(self.name_owner_changed_sig_handler,
+                                         signal_name="NameOwnerChanged",
+                                         dbus_interface="org.freedesktop.DBus")
+
+        sys_bus.add_signal_receiver(self.catchall_signal_handler,
+                                         dbus_interface=NM_IFACE) 
+
+        sys_bus.add_signal_receiver(self.catchall_signal_handler,
+                                         dbus_interface=NM_IFACE + 'Devices')
+
+        for (signal, handler) in self._sig_handlers.items():
+            sys_bus.add_signal_receiver(handler, signal_name=signal, dbus_interface=NM_IFACE)
+
+        # Find out whether or not NM is running
+        try:
+            bus_object = sys_bus.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus')
+            name = bus_object.GetNameOwner("org.freedesktop.NetworkManagerInfo", \
+                    dbus_interface='org.freedesktop.DBus')
+            if name:
+                self._nm_present = True
+        except dbus.DBusException:
+            pass
+
+    @dbus.decorators.explicitly_pass_message
+    def catchall_signal_handler(self, *args, **keywords):
+        dbus_message = keywords['dbus_message']
+        mem = dbus_message.get_member()
+        iface = dbus_message.get_interface()
+
+        if iface == NM_IFACE and mem in self._sig_handlers.keys():
+            return
+
+         logging.debug('Caught signal %s.%s' % (dbus_message.get_interface(), mem))
+        for arg in args:
+            logging.debug('        ' + str(arg))
+
+    def _menu_item_clicked_cb(self, widget, event, dev_data):
+        (device, network) = dev_data
+        net_op = ""
+        if network:
+            net_op = network.get_op()
+        try:
+            # NM 0.6.4 and earlier have a bug which returns an
+            # InvalidArguments error if no security information is passed
+            # for wireless networks
+            self._nm_obj.setActiveDevice(device.get_op(), network.get_ssid())
+        except dbus.DBusException, e:
+            if str(e).find("invalid arguments"):
+                pass
+            else:
+                raise dbus.DBusException(e)
+
+        self._popdown()
+
+    def get_key_for_network(self, net, async_cb, async_err_cb):
+        # Throw up a dialog asking for the key here, and set
+        # the authentication algorithm to the given one, if any
+        #
+        # Key needs to be limited to _either_ 10 or 26 digits long,
+        # and contain _only_ _hex_ digits, 0-9 or a-f
+        #
+        # Auth algorithm should be a dropdown of: [Open System, Shared Key],
+        # mapping to the values [IW_AUTH_ALG_OPEN_SYSTEM, IW_AUTH_ALG_SHARED_KEY]
+        # above
+
+        self._key_dialog = WEPKeyDialog(net, async_cb, async_err_cb)
+        self._key_dialog.connect("response", self._key_dialog_response_cb)
+        self._key_dialog.connect("destroy", self._key_dialog_destroy_cb)
+        self._key_dialog.show_all()
+
+    def _key_dialog_destroy_cb(self, widget, foo=None):
+        if widget != self._key_dialog:
+            return
+        self._key_dialog_response_cb(widget, gtk.RESPONSE_CANCEL)
+
+    def _key_dialog_response_cb(self, widget, response_id):
+        if widget != self._key_dialog:
+            return
+        key = self._key_dialog.get_key()
+        wep_auth_alg = self._key_dialog.get_auth_alg()
+        net = self._key_dialog.get_network()
+        (async_cb, async_err_cb) = self._key_dialog.get_callbacks()
+
+        # Clear self._key_dialog before we call destroy(), otherwise
+        # the destroy will trigger and we'll get called again by
+        # self._key_dialog_destroy_cb
+        self._key_dialog = None
+        widget.destroy()
+
+        if response_id == gtk.RESPONSE_OK:
+            self.nminfo.get_key_for_network_cb(
+                    net, key, wep_auth_alg, async_cb, async_err_cb, canceled=False)
+        else:
+            self.nminfo.get_key_for_network_cb(
+                    net, None, None, async_cb, async_err_cb, canceled=True)
+
+    def cancel_get_key_for_network(self):
+        # Close the wireless key dialog and just have it return
+        # with the 'canceled' argument set to true
+        if not self._key_dialog:
+            return
+        self._key_dialog_destroy_cb(self._key_dialog)
+
+    def device_activation_stage_sig_handler(self, device, stage):
+        logging.debug('Device Activation Stage "%s" for device %s' % (NM_DEVICE_STAGE_STRINGS[stage], device))
+
+    def state_change_sig_handler(self, state):
+        self._nm_state = state
+        self._schedule_icon_update(immediate=True)
+
+    def device_activating_sig_handler(self, device):
+        self._active_device = device
+
+    def device_now_active_sig_handler(self, device, ssid=None):
+        if not self._devices.has_key(device):
+            return
+        self._active_device = device
+        self._devices[device].set_active(True, ssid)
+        self._schedule_icon_update(immediate=True)
+
+    def device_no_longer_active_sig_handler(self, device):
+        if not self._devices.has_key(device):
+            return
+        if self._active_device == device:
+            self._active_device = None
+        self._devices[device].set_active(False)
+        self._schedule_icon_update(immediate=True)
+
+    def name_owner_changed_sig_handler(self, name, old, new):
+        if name != NM_SERVICE:
+            return
+        if (old and len(old)) and (not new and not len(new)):
+            # NM went away
+            self._nm_present = False
+            self._schedule_icon_update(immediate=True)
+            for op in self._devices.keys():
+                del self._devices[op]
+            self._devices = {}
+            self._active_device = None
+            self._nm_state = NM_STATE_UNKNOWN
+        elif (not old and not len(old)) and (new and len(new)):
+            # NM started up
+            self._nm_present = True
+            self._get_nm_state()
+            self._get_initial_devices()
+
+    def device_added_sig_handler(self, device):
+        self._add_device(device)
+
+    def device_removed_sig_handler(self, device):
+        self._remove_device(device)
+
+    def wireless_network_appeared_sig_handler(self, device, network):
+        if not self._devices.has_key(device):
+            return
+        self._devices[device].network_appeared(network)
+
+    def wireless_network_disappeared_sig_handler(self, device, network):
+        if not self._devices.has_key(device):
+            return
+        self._devices[device].network_disappeared(network)
+
+    def wireless_device_strength_changed_sig_handler(self, device, strength):
+        if not self._devices.has_key(device):
+            return
+        self._devices[device].set_strength(strength)
+
+    def wireless_network_strength_changed_sig_handler(self, device, network, strength):
+        if not self._devices.has_key(device):
+            return
+        net = self._devices[device].get_network(network)
+        if net:
+            net.set_strength(strength)
+
+    def device_carrier_on_sig_handler(self, device):
+        if not self._devices.has_key(device):
+            return
+        self._devices[device].set_carrier(True)
+
+    def device_carrier_off_sig_handler(self, device):
+        if not self._devices.has_key(device):
+            return
+        self._devices[device].set_carrier(False)
+
+    def run(self):
+        loop = gobject.MainLoop()
+        try:
+            loop.run()
+        except KeyboardInterrupt:
+            pass
 
diff --git a/services/nm/nminfo.py b/services/nm/nminfo.py
index a86ec1a..f512a8b 100644
--- a/services/nm/nminfo.py
+++ b/services/nm/nminfo.py
@@ -26,65 +26,65 @@ import logging
 
 import nmclient
 try:
-	from sugar import env
+    from sugar import env
 except ImportError:
-	pass
+    pass
 
 NM_INFO_IFACE='org.freedesktop.NetworkManagerInfo'
 NM_INFO_PATH='/org/freedesktop/NetworkManagerInfo'
 
 
 class NoNetworks(dbus.DBusException):
-	def __init__(self):
-		dbus.DBusException.__init__(self)
-		self._dbus_error_name = NM_INFO_IFACE + '.NoNetworks'
+    def __init__(self):
+        dbus.DBusException.__init__(self)
+        self._dbus_error_name = NM_INFO_IFACE + '.NoNetworks'
 
 class CanceledKeyRequestError(dbus.DBusException):
-	def __init__(self):
-		dbus.DBusException.__init__(self)
-		self._dbus_error_name = NM_INFO_IFACE + '.CanceledError'
+    def __init__(self):
+        dbus.DBusException.__init__(self)
+        self._dbus_error_name = NM_INFO_IFACE + '.CanceledError'
 
 
 class NetworkInvalidError(Exception):
-	pass
+    pass
 
 
 class NMConfig(ConfigParser.ConfigParser):
-	def get_bool(self, section, name):
-		opt = self.get(section, name)
-		if type(opt) == type(""):
-			if opt.lower() == 'yes' or opt.lower() == 'true':
-				return True
-			elif opt.lower() == 'no' or opt.lower() == 'false':
-				return False
-		raise ValueError("Invalid format for %s/%s.  Should be one of [yes, no, true, false]." % (section, name))
-
-	def get_list(self, section, name):
-		opt = self.get(section, name)
-		if type(opt) == type(""):
-			if not len(opt):
-				return []
-			try:
-				return opt.split()
-			except Exception:
-				pass
-		raise ValueError("Invalid format for %s/%s.  Should be a space-separate list." % (section, name))
-
-	def get_int(self, section, name):
-		opt = self.get(section, name)
-		try:
-			return int(opt)
-		except Exception:
-			pass
-		raise ValueError("Invalid format for %s/%s.  Should be a valid integer." % (section, name))
-
-	def get_float(self, section, name):
-		opt = self.get(section, name)
-		try:
-			return float(opt)
-		except Exception:
-			pass
-		raise ValueError("Invalid format for %s/%s.  Should be a valid float." % (section, name))
+    def get_bool(self, section, name):
+        opt = self.get(section, name)
+        if type(opt) == type(""):
+            if opt.lower() == 'yes' or opt.lower() == 'true':
+                return True
+            elif opt.lower() == 'no' or opt.lower() == 'false':
+                return False
+        raise ValueError("Invalid format for %s/%s.  Should be one of [yes, no, true, false]." % (section, name))
+
+    def get_list(self, section, name):
+        opt = self.get(section, name)
+        if type(opt) == type(""):
+            if not len(opt):
+                return []
+            try:
+                return opt.split()
+            except Exception:
+                pass
+        raise ValueError("Invalid format for %s/%s.  Should be a space-separate list." % (section, name))
+
+    def get_int(self, section, name):
+        opt = self.get(section, name)
+        try:
+            return int(opt)
+        except Exception:
+            pass
+        raise ValueError("Invalid format for %s/%s.  Should be a valid integer." % (section, name))
+
+    def get_float(self, section, name):
+        opt = self.get(section, name)
+        try:
+            return float(opt)
+        except Exception:
+            pass
+        raise ValueError("Invalid format for %s/%s.  Should be a valid float." % (section, name))
 
 
 IW_AUTH_CIPHER_NONE   = 0x00000001
@@ -102,366 +102,366 @@ NETWORK_TYPE_INVALID = 2
 
 
 class Security(object):
-	def __init__(self, we_cipher):
-		self._we_cipher = we_cipher
-
-	def read_from_config(self, cfg, name):
-		pass
-
-	def read_from_args(self, args):
-		pass
-
-	def new_from_config(cfg, name):
-		security = None
-		try:
-			we_cipher = cfg.get_int(name, "we_cipher")
-			if we_cipher == IW_AUTH_CIPHER_NONE:
-				security = Security(we_cipher)
-			elif we_cipher == IW_AUTH_CIPHER_WEP40 or we_cipher == IW_AUTH_CIPHER_WEP104:
-				security = WEPSecurity(we_cipher)
-			else:
-				# FIXME: find a way to make WPA config option matrix not
-				# make you want to throw up
-				raise ValueError("Unsupported security combo")
-			security.read_from_config(cfg, name)
-		except (ConfigParser.NoOptionError, ValueError), e:
-			return None
-		return security
-	new_from_config = staticmethod(new_from_config)
-
-	def new_from_args(we_cipher, args):
-		security = None
-		try:
-			if we_cipher == IW_AUTH_CIPHER_NONE:
-				security = Security(we_cipher)
-			elif we_cipher == IW_AUTH_CIPHER_WEP40 or we_cipher == IW_AUTH_CIPHER_WEP104:
-				security = WEPSecurity(we_cipher)
-			else:
-				# FIXME: find a way to make WPA config option matrix not
-				# make you want to throw up
-				raise ValueError("Unsupported security combo")
-			security.read_from_args(args)
-		except ValueError, e:
-			logging.debug("Error reading security information: %s" % e)
-			del security
-			return None
-		return security
-	new_from_args = staticmethod(new_from_args)
-
-	def get_properties(self):
-		return [dbus.Int32(self._we_cipher)]
-
-	def write_to_config(self, section, config):
-		config.set(section, "we_cipher", self._we_cipher)
+    def __init__(self, we_cipher):
+        self._we_cipher = we_cipher
+
+    def read_from_config(self, cfg, name):
+        pass
+
+    def read_from_args(self, args):
+        pass
+
+    def new_from_config(cfg, name):
+        security = None
+        try:
+            we_cipher = cfg.get_int(name, "we_cipher")
+            if we_cipher == IW_AUTH_CIPHER_NONE:
+                security = Security(we_cipher)
+            elif we_cipher == IW_AUTH_CIPHER_WEP40 or we_cipher == IW_AUTH_CIPHER_WEP104:
+                security = WEPSecurity(we_cipher)
+            else:
+                # FIXME: find a way to make WPA config option matrix not
+                # make you want to throw up
+                raise ValueError("Unsupported security combo")
+            security.read_from_config(cfg, name)
+        except (ConfigParser.NoOptionError, ValueError), e:
+            return None
+        return security
+    new_from_config = staticmethod(new_from_config)
+
+    def new_from_args(we_cipher, args):
+        security = None
+        try:
+            if we_cipher == IW_AUTH_CIPHER_NONE:
+                security = Security(we_cipher)
+            elif we_cipher == IW_AUTH_CIPHER_WEP40 or we_cipher == IW_AUTH_CIPHER_WEP104:
+                security = WEPSecurity(we_cipher)
+            else:
+                # FIXME: find a way to make WPA config option matrix not
+                # make you want to throw up
+                raise ValueError("Unsupported security combo")
+            security.read_from_args(args)
+        except ValueError, e:
+            logging.debug("Error reading security information: %s" % e)
+            del security
+            return None
+        return security
+    new_from_args = staticmethod(new_from_args)
+
+    def get_properties(self):
+        return [dbus.Int32(self._we_cipher)]
+
+    def write_to_config(self, section, config):
+        config.set(section, "we_cipher", self._we_cipher)
 
 
 class WEPSecurity(Security):
-	def read_from_args(self, args):
-		if len(args) != 2:
-			raise ValueError("not enough arguments")
-		key = args[0]
-		auth_alg = args[1]
-		if isinstance(key, unicode):
-			key = key.encode()
-		if not isinstance(key, str):
-			raise ValueError("wrong argument type for key")
-		if not isinstance(auth_alg, int):
-			raise ValueError("wrong argument type for auth_alg")
-		self._key = key
-		self._auth_alg = auth_alg
-
-	def read_from_config(self, cfg, name):
-		# Key should be a hex encoded string
-		self._key = cfg.get(name, "key")
-		if self._we_cipher == IW_AUTH_CIPHER_WEP40 and len(self._key) != 10:
-			raise ValueError("Key length not right for 40-bit WEP")
-		if self._we_cipher == IW_AUTH_CIPHER_WEP104 and len(self._key) != 26:
-			raise ValueError("Key length not right for 104-bit WEP")
-
-		try:
-			a = binascii.a2b_hex(self._key)
-		except TypeError:
-			raise ValueError("Key was not a hexadecimal string.")
-			
-		self._auth_alg = cfg.get_int(name, "auth_alg")
-		if self._auth_alg != IW_AUTH_ALG_OPEN_SYSTEM and self._auth_alg != IW_AUTH_ALG_SHARED_KEY:
-			raise ValueError("Invalid authentication algorithm %d" % self._auth_alg)
-
-	def get_properties(self):
-		args = Security.get_properties(self)
-		args.append(dbus.String(self._key))
-		args.append(dbus.Int32(self._auth_alg))
-		return args
-
-	def write_to_config(self, section, config):
-		Security.write_to_config(self, section, config)
-		config.set(section, "key", self._key)
-		config.set(section, "auth_alg", self._auth_alg)
+    def read_from_args(self, args):
+        if len(args) != 2:
+            raise ValueError("not enough arguments")
+        key = args[0]
+        auth_alg = args[1]
+        if isinstance(key, unicode):
+            key = key.encode()
+        if not isinstance(key, str):
+            raise ValueError("wrong argument type for key")
+        if not isinstance(auth_alg, int):
+            raise ValueError("wrong argument type for auth_alg")
+        self._key = key
+        self._auth_alg = auth_alg
+
+    def read_from_config(self, cfg, name):
+        # Key should be a hex encoded string
+        self._key = cfg.get(name, "key")
+        if self._we_cipher == IW_AUTH_CIPHER_WEP40 and len(self._key) != 10:
+            raise ValueError("Key length not right for 40-bit WEP")
+        if self._we_cipher == IW_AUTH_CIPHER_WEP104 and len(self._key) != 26:
+            raise ValueError("Key length not right for 104-bit WEP")
+
+        try:
+            a = binascii.a2b_hex(self._key)
+        except TypeError:
+            raise ValueError("Key was not a hexadecimal string.")
+            
+        self._auth_alg = cfg.get_int(name, "auth_alg")
+        if self._auth_alg != IW_AUTH_ALG_OPEN_SYSTEM and self._auth_alg != IW_AUTH_ALG_SHARED_KEY:
+            raise ValueError("Invalid authentication algorithm %d" % self._auth_alg)
+
+    def get_properties(self):
+        args = Security.get_properties(self)
+        args.append(dbus.String(self._key))
+        args.append(dbus.Int32(self._auth_alg))
+        return args
+
+    def write_to_config(self, section, config):
+        Security.write_to_config(self, section, config)
+        config.set(section, "key", self._key)
+        config.set(section, "auth_alg", self._auth_alg)
 
 
 class Network:
-	def __init__(self, ssid):
-		self.ssid = ssid
-		self.timestamp = int(time.time())
-		self.bssids = []
-		self.we_cipher = 0
-		self._security = None
-
-	def get_properties(self):
-		bssid_list = dbus.Array([], signature="s")
-		for item in self.bssids:
-			bssid_list.append(dbus.String(item))
-		args = [dbus.String(self.ssid), dbus.Int32(self.timestamp), dbus.Boolean(True), bssid_list]
-		args += self._security.get_properties()
-		return tuple(args)
-
-	def get_security(self):
-		return self._security.get_properties()
-
-	def set_security(self, security):
-		self._security = security
-
-	def read_from_args(self, auto, bssid, we_cipher, args):
-		if auto == False:
-			self.timestamp = int(time.time())
-		if not bssid in self.bssids:
-			self.bssids.append(bssid)
-
-		self._security = Security.new_from_args(we_cipher, args)
-		if not self._security:
-			raise NetworkInvalidError("Invalid security information")
-
-	def read_from_config(self, config):
-		try:
-			self.timestamp = config.get_int(self.ssid, "timestamp")
-		except (ConfigParser.NoOptionError, ValueError), e:
-			raise NetworkInvalidError(e)
-
-		self._security = Security.new_from_config(config, self.ssid)
-		if not self._security:
-			raise NetworkInvalidError(e)
-
-		# The following don't need to be present
-		try:
-			self.bssids = config.get_list(self.ssid, "bssids")
-		except (ConfigParser.NoOptionError, ValueError), e:
-			pass
-
-	def write_to_config(self, config):
-		try:
-			config.add_section(self.ssid)
-			config.set(self.ssid, "timestamp", self.timestamp)
-			if len(self.bssids) > 0:
-				opt = " "
-				opt.join(self.bssids)
-				config.set(self.ssid, "bssids", opt)
-			self._security.write_to_config(self.ssid, config)
-		except Exception, e:
-			logging.debug("Error writing '%s': %s" % (self.ssid, e))
+    def __init__(self, ssid):
+        self.ssid = ssid
+        self.timestamp = int(time.time())
+        self.bssids = []
+        self.we_cipher = 0
+        self._security = None
+
+    def get_properties(self):
+        bssid_list = dbus.Array([], signature="s")
+        for item in self.bssids:
+            bssid_list.append(dbus.String(item))
+        args = [dbus.String(self.ssid), dbus.Int32(self.timestamp), dbus.Boolean(True), bssid_list]
+        args += self._security.get_properties()
+        return tuple(args)
+
+    def get_security(self):
+        return self._security.get_properties()
+
+    def set_security(self, security):
+        self._security = security
+
+    def read_from_args(self, auto, bssid, we_cipher, args):
+        if auto == False:
+            self.timestamp = int(time.time())
+        if not bssid in self.bssids:
+            self.bssids.append(bssid)
+
+        self._security = Security.new_from_args(we_cipher, args)
+        if not self._security:
+            raise NetworkInvalidError("Invalid security information")
+
+    def read_from_config(self, config):
+        try:
+            self.timestamp = config.get_int(self.ssid, "timestamp")
+        except (ConfigParser.NoOptionError, ValueError), e:
+            raise NetworkInvalidError(e)
+
+        self._security = Security.new_from_config(config, self.ssid)
+        if not self._security:
+            raise NetworkInvalidError(e)
+
+        # The following don't need to be present
+        try:
+            self.bssids = config.get_list(self.ssid, "bssids")
+        except (ConfigParser.NoOptionError, ValueError), e:
+            pass
+
+    def write_to_config(self, config):
+        try:
+            config.add_section(self.ssid)
+            config.set(self.ssid, "timestamp", self.timestamp)
+            if len(self.bssids) > 0:
+                opt = " "
+                opt.join(self.bssids)
+                config.set(self.ssid, "bssids", opt)
+            self._security.write_to_config(self.ssid, config)
+        except Exception, e:
+            logging.debug("Error writing '%s': %s" % (self.ssid, e))
 
 
 class NotFoundError(dbus.DBusException):
-	pass
+    pass
 class UnsupportedError(dbus.DBusException):
-	pass
+    pass
 
 class NMInfoDBusServiceHelper(dbus.service.Object):
-	def __init__(self, parent):
-		self._parent = parent
-		bus = dbus.SystemBus()
-
-		# If NMI is already around, don't grab the NMI service
-		bus_object = bus.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus')
-		name = None
-		try:
-			name = bus_object.GetNameOwner("org.freedesktop.NetworkManagerInfo", \
-					dbus_interface='org.freedesktop.DBus')
-		except dbus.DBusException:
-			pass
-		if name:
-			logging.debug("NMI service already owned by %s, won't claim it." % name)
-			raise RuntimeError
-
-		bus_name = dbus.service.BusName(NM_INFO_IFACE, bus=bus)
-		dbus.service.Object.__init__(self, bus_name, NM_INFO_PATH)
-
-	@dbus.service.method(NM_INFO_IFACE, in_signature='i', out_signature='as')
-	def getNetworks(self, net_type):
-		ssids = self._parent.get_networks(net_type)
-		if len(ssids) > 0:
-			return dbus.Array(ssids)
-
-		raise NoNetworks()
-
-	@dbus.service.method(NM_INFO_IFACE, in_signature='si', async_callbacks=('async_cb', 'async_err_cb'))
-	def getNetworkProperties(self, ssid, net_type, async_cb, async_err_cb):
-		self._parent.get_network_properties(ssid, net_type, async_cb, async_err_cb)
-
-	@dbus.service.method(NM_INFO_IFACE)
-	def updateNetworkInfo(self, ssid, bauto, bssid, cipher, *args):
-		self._parent.update_network_info(ssid, bauto, bssid, cipher, args)
-
-	@dbus.service.method(NM_INFO_IFACE, async_callbacks=('async_cb', 'async_err_cb'))
-	def getKeyForNetwork(self, dev_path, net_path, ssid, attempt, new_key, async_cb, async_err_cb):
-		self._parent.get_key_for_network(dev_path, net_path, ssid,
-				attempt, new_key, async_cb, async_err_cb)
-
-	@dbus.service.method(NM_INFO_IFACE)
-	def cancelGetKeyForNetwork(self):
-		self._parent.cancel_get_key_for_network()
+    def __init__(self, parent):
+        self._parent = parent
+        bus = dbus.SystemBus()
+
+        # If NMI is already around, don't grab the NMI service
+        bus_object = bus.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus')
+        name = None
+        try:
+            name = bus_object.GetNameOwner("org.freedesktop.NetworkManagerInfo", \
+                    dbus_interface='org.freedesktop.DBus')
+        except dbus.DBusException:
+            pass
+        if name:
+            logging.debug("NMI service already owned by %s, won't claim it." % name)
+            raise RuntimeError
+
+        bus_name = dbus.service.BusName(NM_INFO_IFACE, bus=bus)
+        dbus.service.Object.__init__(self, bus_name, NM_INFO_PATH)
+
+    @dbus.service.method(NM_INFO_IFACE, in_signature='i', out_signature='as')
+    def getNetworks(self, net_type):
+        ssids = self._parent.get_networks(net_type)
+        if len(ssids) > 0:
+            return dbus.Array(ssids)
+
+        raise NoNetworks()
+
+    @dbus.service.method(NM_INFO_IFACE, in_signature='si', async_callbacks=('async_cb', 'async_err_cb'))
+    def getNetworkProperties(self, ssid, net_type, async_cb, async_err_cb):
+        self._parent.get_network_properties(ssid, net_type, async_cb, async_err_cb)
+
+    @dbus.service.method(NM_INFO_IFACE)
+    def updateNetworkInfo(self, ssid, bauto, bssid, cipher, *args):
+        self._parent.update_network_info(ssid, bauto, bssid, cipher, args)
+
+    @dbus.service.method(NM_INFO_IFACE, async_callbacks=('async_cb', 'async_err_cb'))
+    def getKeyForNetwork(self, dev_path, net_path, ssid, attempt, new_key, async_cb, async_err_cb):
+        self._parent.get_key_for_network(dev_path, net_path, ssid,
+                attempt, new_key, async_cb, async_err_cb)
+
+    @dbus.service.method(NM_INFO_IFACE)
+    def cancelGetKeyForNetwork(self):
+        self._parent.cancel_get_key_for_network()
 
 class NMInfo(object):
-	def __init__(self, client):
-		try:
-			profile_path = env.get_profile_path()
-		except NameError:
-			home = os.path.expanduser("~")
-			profile_path = os.path.join(home, ".sugar", "default")
-		self._cfg_file = os.path.join(profile_path, "nm", "networks.cfg")
-		self._nmclient = client
-		self._allowed_networks = self._read_config()
-		self._dbus_helper = NMInfoDBusServiceHelper(self)
-
-	def save_config(self):
-		self._write_config(self._allowed_networks)
-
-	def _read_config(self):
-		if not os.path.exists(os.path.dirname(self._cfg_file)):
-			os.makedirs(os.path.dirname(self._cfg_file), 0755)
-		if not os.path.exists(self._cfg_file):
-			self._write_config({})
-			return {}
-
-		config = NMConfig()
-		config.read(self._cfg_file)
-		networks = {}
-		for name in config.sections():
-			if not isinstance(name, unicode):
-				name = unicode(name)
-			net = Network(name)
-			try:
-				net.read_from_config(config)
-				networks[name] = net
-			except NetworkInvalidError, e:
-				logging.debug("Error: invalid stored network config: %s" % e)
-				del net
-		del config
-		return networks
-
-	def _write_config(self, networks):
-		fp = open(self._cfg_file, 'w')
-		config = NMConfig()
-		for net in networks.values():
-			net.write_to_config(config)
-		config.write(fp)
-		fp.close()
-		del config
-
-	def get_networks(self, net_type):
-		if net_type != NETWORK_TYPE_ALLOWED:
-			raise ValueError("Bad network type")
-		nets = []
-		for net in self._allowed_networks.values():
-			nets.append(net.ssid)
-		logging.debug("Returning networks: %s" % nets)
-		return nets
-
-	def get_network_properties(self, ssid, net_type, async_cb, async_err_cb):
-		if not isinstance(ssid, unicode):
-			async_err_cb(ValueError("Invalid arguments; ssid must be unicode."))
-		if net_type != NETWORK_TYPE_ALLOWED:
-			async_err_cb(ValueError("Bad network type"))
-		if not self._allowed_networks.has_key(ssid):
-			async_err_cb(NotFoundError("Network '%s' not found." % ssid))
-		network = self._allowed_networks[ssid]
-		props = network.get_properties()
-
-		# DBus workaround: the normal method return handler wraps
-		# the returned arguments in a tuple and then converts that to a
-		# struct, but NetworkManager expects a plain list of arguments.
-		# It turns out that the async callback method return code _doesn't_
-		# wrap the returned arguments in a tuple, so as a workaround use
-		# the async callback stuff here even though we're not doing it
-		# asynchronously.
-		async_cb(*props)
-
-	def update_network_info(self, ssid, auto, bssid, we_cipher, args):
-		if not isinstance(ssid, unicode):
-			raise ValueError("Invalid arguments; ssid must be unicode.")
-		if self._allowed_networks.has_key(ssid):
-			del self._allowed_networks[ssid]
-		net = Network(ssid)
-		try:
-			net.read_from_args(auto, bssid, we_cipher, args)
-			logging.debug("Updated network information for '%s'." % ssid)
-			self._allowed_networks[ssid] = net
-			self.save_config()
-		except NetworkInvalidError, e:
-			logging.debug("Error updating network information: %s" % e)
-			del net
-
-	def get_key_for_network(self, dev_op, net_op, ssid, attempt, new_key, async_cb, async_err_cb):
-		if not isinstance(ssid, unicode):
-			raise ValueError("Invalid arguments; ssid must be unicode.")
-		if self._allowed_networks.has_key(ssid) and not new_key:
-			# We've got the info already
-			net = self._allowed_networks[ssid]
-			async_cb(tuple(net.get_security()))
-			return
-
-		# Otherwise, ask the user for it
-		net = None
-		dev = self._nmclient.get_device(dev_op)
-		if not dev:
-			async_err_cb(NotFoundError("Device was unknown."))
-			return
-
-		if dev.get_type() == nmclient.DEVICE_TYPE_802_3_ETHERNET:
-			# We don't support wired 802.1x yet...
-			async_err_cb(UnsupportedError("Device type is unsupported by NMI."))
-			return
-
-		net = dev.get_network(net_op)
-		if not net:
-			async_err_cb(NotFoundError("Network was unknown."))
-			return
-
-		self._nmclient.get_key_for_network(net, async_cb, async_err_cb)
-
-	def get_key_for_network_cb(self, net, key, auth_alg, async_cb, async_err_cb, canceled=False):
-		"""
-		Called by the NMClient when the Wireless Network Key dialog
-		is closed.
-		"""
-		if canceled:
-			e = CanceledKeyRequestError("Request was canceled.")
-			# key dialog dialog was canceled; send the error back to NM
-			async_err_cb(e)
-			return
-
-		if not key or not auth_alg:
-			# no key returned, *** BUG ***; the key dialog
-			# should always return either a key + auth_alg, or a
-			#cancel error
-			raise RuntimeError("No key or auth alg given! Bug!")
-
-		we_cipher = None
-		if len(key) == 26:
-			we_cipher = IW_AUTH_CIPHER_WEP104
-		elif len(key) == 10:
-			we_cipher = IW_AUTH_CIPHER_WEP40
-		else:
-			raise RuntimeError("Invalid key length!")
-
-		# Stuff the returned key and auth algorithm into a security object
-		# and return it to NetworkManager
-		sec = Security.new_from_args(we_cipher, (key, auth_alg))
-		if not sec:
-			raise RuntimeError("Invalid security arguments.")
-		props = sec.get_properties()
-		a = tuple(props)
-		async_cb(*a)
-
-	def cancel_get_key_for_network(self):
-		# Tell the NMClient to close the key request dialog
-		self._nmclient.cancel_get_key_for_network()
+    def __init__(self, client):
+        try:
+            profile_path = env.get_profile_path()
+        except NameError:
+            home = os.path.expanduser("~")
+            profile_path = os.path.join(home, ".sugar", "default")
+        self._cfg_file = os.path.join(profile_path, "nm", "networks.cfg")
+        self._nmclient = client
+        self._allowed_networks = self._read_config()
+        self._dbus_helper = NMInfoDBusServiceHelper(self)
+
+    def save_config(self):
+        self._write_config(self._allowed_networks)
+
+    def _read_config(self):
+        if not os.path.exists(os.path.dirname(self._cfg_file)):
+            os.makedirs(os.path.dirname(self._cfg_file), 0755)
+        if not os.path.exists(self._cfg_file):
+            self._write_config({})
+            return {}
+
+        config = NMConfig()
+        config.read(self._cfg_file)
+        networks = {}
+        for name in config.sections():
+            if not isinstance(name, unicode):
+                name = unicode(name)
+            net = Network(name)
+            try:
+                net.read_from_config(config)
+                networks[name] = net
+            except NetworkInvalidError, e:
+                logging.debug("Error: invalid stored network config: %s" % e)
+                del net
+        del config
+        return networks
+
+    def _write_config(self, networks):
+        fp = open(self._cfg_file, 'w')
+        config = NMConfig()
+        for net in networks.values():
+            net.write_to_config(config)
+        config.write(fp)
+        fp.close()
+        del config
+
+    def get_networks(self, net_type):
+        if net_type != NETWORK_TYPE_ALLOWED:
+            raise ValueError("Bad network type")
+        nets = []
+        for net in self._allowed_networks.values():
+            nets.append(net.ssid)
+        logging.debug("Returning networks: %s" % nets)
+        return nets
+
+    def get_network_properties(self, ssid, net_type, async_cb, async_err_cb):
+        if not isinstance(ssid, unicode):
+            async_err_cb(ValueError("Invalid arguments; ssid must be unicode."))
+        if net_type != NETWORK_TYPE_ALLOWED:
+            async_err_cb(ValueError("Bad network type"))
+        if not self._allowed_networks.has_key(ssid):
+            async_err_cb(NotFoundError("Network '%s' not found." % ssid))
+        network = self._allowed_networks[ssid]
+        props = network.get_properties()
+
+        # DBus workaround: the normal method return handler wraps
+        # the returned arguments in a tuple and then converts that to a
+        # struct, but NetworkManager expects a plain list of arguments.
+        # It turns out that the async callback method return code _doesn't_
+        # wrap the returned arguments in a tuple, so as a workaround use
+        # the async callback stuff here even though we're not doing it
+        # asynchronously.
+        async_cb(*props)
+
+    def update_network_info(self, ssid, auto, bssid, we_cipher, args):
+        if not isinstance(ssid, unicode):
+            raise ValueError("Invalid arguments; ssid must be unicode.")
+        if self._allowed_networks.has_key(ssid):
+            del self._allowed_networks[ssid]
+        net = Network(ssid)
+        try:
+            net.read_from_args(auto, bssid, we_cipher, args)
+            logging.debug("Updated network information for '%s'." % ssid)
+            self._allowed_networks[ssid] = net
+            self.save_config()
+        except NetworkInvalidError, e:
+            logging.debug("Error updating network information: %s" % e)
+            del net
+
+    def get_key_for_network(self, dev_op, net_op, ssid, attempt, new_key, async_cb, async_err_cb):
+        if not isinstance(ssid, unicode):
+            raise ValueError("Invalid arguments; ssid must be unicode.")
+        if self._allowed_networks.has_key(ssid) and not new_key:
+            # We've got the info already
+            net = self._allowed_networks[ssid]
+            async_cb(tuple(net.get_security()))
+            return
+
+        # Otherwise, ask the user for it
+        net = None
+        dev = self._nmclient.get_device(dev_op)
+        if not dev:
+            async_err_cb(NotFoundError("Device was unknown."))
+            return
+
+        if dev.get_type() == nmclient.DEVICE_TYPE_802_3_ETHERNET:
+            # We don't support wired 802.1x yet...
+            async_err_cb(UnsupportedError("Device type is unsupported by NMI."))
+            return
+
+        net = dev.get_network(net_op)
+        if not net:
+            async_err_cb(NotFoundError("Network was unknown."))
+            return
+
+        self._nmclient.get_key_for_network(net, async_cb, async_err_cb)
+
+    def get_key_for_network_cb(self, net, key, auth_alg, async_cb, async_err_cb, canceled=False):
+        """
+        Called by the NMClient when the Wireless Network Key dialog
+        is closed.
+        """
+        if canceled:
+            e = CanceledKeyRequestError("Request was canceled.")
+            # key dialog dialog was canceled; send the error back to NM
+            async_err_cb(e)
+            return
+
+        if not key or not auth_alg:
+            # no key returned, *** BUG ***; the key dialog
+            # should always return either a key + auth_alg, or a
+            #cancel error
+            raise RuntimeError("No key or auth alg given! Bug!")
+
+        we_cipher = None
+        if len(key) == 26:
+            we_cipher = IW_AUTH_CIPHER_WEP104
+        elif len(key) == 10:
+            we_cipher = IW_AUTH_CIPHER_WEP40
+        else:
+            raise RuntimeError("Invalid key length!")
+
+        # Stuff the returned key and auth algorithm into a security object
+        # and return it to NetworkManager
+        sec = Security.new_from_args(we_cipher, (key, auth_alg))
+        if not sec:
+            raise RuntimeError("Invalid security arguments.")
+        props = sec.get_properties()
+        a = tuple(props)
+        async_cb(*a)
+
+    def cancel_get_key_for_network(self):
+        # Tell the NMClient to close the key request dialog
+        self._nmclient.cancel_get_key_for_network()
diff --git a/services/nm/wepkeydialog.py b/services/nm/wepkeydialog.py
index 40c8a0b..fc35ee1 100644
--- a/services/nm/wepkeydialog.py
+++ b/services/nm/wepkeydialog.py
@@ -22,60 +22,60 @@ IW_AUTH_ALG_OPEN_SYSTEM = 0x00000001
 IW_AUTH_ALG_SHARED_KEY  = 0x00000002
 
 class WEPKeyDialog(gtk.Dialog):
-	def __init__(self, net, async_cb, async_err_cb):
-		gtk.Dialog.__init__(self)
-		self.set_title("Wireless Key Required")
+    def __init__(self, net, async_cb, async_err_cb):
+        gtk.Dialog.__init__(self)
+        self.set_title("Wireless Key Required")
 
-		self._net = net
-		self._async_cb = async_cb
-		self._async_err_cb = async_err_cb
+        self._net = net
+        self._async_cb = async_cb
+        self._async_err_cb = async_err_cb
 
-		self.set_has_separator(False)		
+        self.set_has_separator(False)        
 
-		label = gtk.Label("A wireless encryption key is required for\n" \
-			" the wireless network '%s'." % net.get_ssid())
-		self.vbox.pack_start(label)
+        label = gtk.Label("A wireless encryption key is required for\n" \
+            " the wireless network '%s'." % net.get_ssid())
+        self.vbox.pack_start(label)
 
-		self._entry = gtk.Entry()
-		self._entry.props.visibility = False
-		self._entry.connect('changed', self._entry_changed_cb)
-		self.vbox.pack_start(self._entry)
-		self.vbox.show_all()
+        self._entry = gtk.Entry()
+        self._entry.props.visibility = False
+        self._entry.connect('changed', self._entry_changed_cb)
+        self.vbox.pack_start(self._entry)
+        self.vbox.show_all()
 
-		self.add_buttons(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
-						 gtk.STOCK_OK, gtk.RESPONSE_OK)
+        self.add_buttons(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
+                         gtk.STOCK_OK, gtk.RESPONSE_OK)
 
-		self.set_default_response(gtk.RESPONSE_OK)
-		self._update_response_sensitivity()
+        self.set_default_response(gtk.RESPONSE_OK)
+        self._update_response_sensitivity()
 
-	def get_key(self):
-		return self._entry.get_text()
+    def get_key(self):
+        return self._entry.get_text()
 
-	def get_auth_alg(self):
-		return IW_AUTH_ALG_OPEN_SYSTEM
+    def get_auth_alg(self):
+        return IW_AUTH_ALG_OPEN_SYSTEM
 
-	def get_network(self):
-		return self._net
+    def get_network(self):
+        return self._net
 
-	def get_callbacks(self):
-		return (self._async_cb, self._async_err_cb)
+    def get_callbacks(self):
+        return (self._async_cb, self._async_err_cb)
 
-	def _entry_changed_cb(self, entry):
-		self._update_response_sensitivity()
+    def _entry_changed_cb(self, entry):
+        self._update_response_sensitivity()
 
-	def _update_response_sensitivity(self):
-		key = self.get_key()
+    def _update_response_sensitivity(self):
+        key = self.get_key()
 
-		is_hex = True
-		for c in key:
-			if not 'a' <= c <= 'f' and not '0' <= c <= '9':
-				is_hex = False
+        is_hex = True
+        for c in key:
+            if not 'a' <= c <= 'f' and not '0' <= c <= '9':
+                is_hex = False
 
-		valid_len = (len(key) == 10 or len(key) == 26)
-	 	self.set_response_sensitive(gtk.RESPONSE_OK, is_hex and valid_len)
+        valid_len = (len(key) == 10 or len(key) == 26)
+         self.set_response_sensitive(gtk.RESPONSE_OK, is_hex and valid_len)
 
 if __name__ == "__main__":
-	dialog = WEPKeyDialog()
-	dialog.run()
+    dialog = WEPKeyDialog()
+    dialog.run()
 
-	print dialog.get_key()
+    print dialog.get_key()
diff --git a/services/presence/Activity.py b/services/presence/Activity.py
index 065fb49..031c036 100644
--- a/services/presence/Activity.py
+++ b/services/presence/Activity.py
@@ -22,155 +22,155 @@ ACTIVITY_DBUS_INTERFACE = "org.laptop.Presence.Activity"
 
 
 class ActivityDBusHelper(dbus.service.Object):
-	def __init__(self, parent, bus_name, object_path):
-		self._parent = parent
-		self._bus_name = bus_name
-		self._object_path = object_path
-		dbus.service.Object.__init__(self, bus_name, self._object_path)
-
-	@dbus.service.method(ACTIVITY_DBUS_INTERFACE,
-						in_signature="s", out_signature="ao")
-	def getServicesOfType(self, stype):
-		ret = []
-		for serv in self._parent.get_services_of_type(stype):
-			ret.append(serv.object_path())
-		return ret
-
-	@dbus.service.method(ACTIVITY_DBUS_INTERFACE,
-						in_signature="", out_signature="ao")
-	def getServices(self):
-		ret = []
-		for serv in self._parent.get_services():
-			ret.append(serv.object_path())
-		return ret
-
-	@dbus.service.method(ACTIVITY_DBUS_INTERFACE,
-						in_signature="", out_signature="s")
-	def getId(self):
-		return self._parent.get_id()
-
-	@dbus.service.method(ACTIVITY_DBUS_INTERFACE,
-						in_signature="", out_signature="s")
-	def getColor(self):
-		return self._parent.get_color()
-
-	@dbus.service.method(ACTIVITY_DBUS_INTERFACE,
-						in_signature="", out_signature="ao")
-	def getJoinedBuddies(self):
-		ret = []
-		for buddy in self._parent.get_joined_buddies():
-			ret.append(buddy.object_path())
-		return ret
-	
-	@dbus.service.signal(ACTIVITY_DBUS_INTERFACE,
-						signature="o")
-	def ServiceAppeared(self, object_path):
-		pass
-
-	@dbus.service.signal(ACTIVITY_DBUS_INTERFACE,
-						signature="o")
-	def ServiceDisappeared(self, object_path):
-		pass
-
-	@dbus.service.signal(ACTIVITY_DBUS_INTERFACE,
-						signature="o")
-	def BuddyJoined(self, object_path):
-		pass
-
-	@dbus.service.signal(ACTIVITY_DBUS_INTERFACE,
-						signature="o")
-	def BuddyLeft(self, object_path):
-		pass
+    def __init__(self, parent, bus_name, object_path):
+        self._parent = parent
+        self._bus_name = bus_name
+        self._object_path = object_path
+        dbus.service.Object.__init__(self, bus_name, self._object_path)
+
+    @dbus.service.method(ACTIVITY_DBUS_INTERFACE,
+                        in_signature="s", out_signature="ao")
+    def getServicesOfType(self, stype):
+        ret = []
+        for serv in self._parent.get_services_of_type(stype):
+            ret.append(serv.object_path())
+        return ret
+
+    @dbus.service.method(ACTIVITY_DBUS_INTERFACE,
+                        in_signature="", out_signature="ao")
+    def getServices(self):
+        ret = []
+        for serv in self._parent.get_services():
+            ret.append(serv.object_path())
+        return ret
+
+    @dbus.service.method(ACTIVITY_DBUS_INTERFACE,
+                        in_signature="", out_signature="s")
+    def getId(self):
+        return self._parent.get_id()
+
+    @dbus.service.method(ACTIVITY_DBUS_INTERFACE,
+                        in_signature="", out_signature="s")
+    def getColor(self):
+        return self._parent.get_color()
+
+    @dbus.service.method(ACTIVITY_DBUS_INTERFACE,
+                        in_signature="", out_signature="ao")
+    def getJoinedBuddies(self):
+        ret = []
+        for buddy in self._parent.get_joined_buddies():
+            ret.append(buddy.object_path())
+        return ret
+    
+    @dbus.service.signal(ACTIVITY_DBUS_INTERFACE,
+                        signature="o")
+    def ServiceAppeared(self, object_path):
+        pass
+
+    @dbus.service.signal(ACTIVITY_DBUS_INTERFACE,
+                        signature="o")
+    def ServiceDisappeared(self, object_path):
+        pass
+
+    @dbus.service.signal(ACTIVITY_DBUS_INTERFACE,
+                        signature="o")
+    def BuddyJoined(self, object_path):
+        pass
+
+    @dbus.service.signal(ACTIVITY_DBUS_INTERFACE,
+                        signature="o")
+    def BuddyLeft(self, object_path):
+        pass
 
 
 class Activity(object):
-	def __init__(self, bus_name, object_id, initial_service):
-		if not initial_service.get_activity_id():
-			raise ValueError("Service must have a valid Activity ID")
-		self._activity_id = initial_service.get_activity_id()
-
-		self._buddies = []
-		self._services = {}	# service type -> list of Services
-		self._color = None
-		self._valid = False
-
-		self._object_id = object_id
-		self._object_path = "/org/laptop/Presence/Activities/%d" % self._object_id
-		self._dbus_helper = ActivityDBusHelper(self, bus_name, self._object_path)
-		
-		self.add_service(initial_service)
-
-	def object_path(self):
-		return dbus.ObjectPath(self._object_path)
-
-	def is_valid(self):
-		"""An activity is only valid when it's color is available."""
-		return self._valid
-
-	def get_id(self):
-		return self._activity_id
-
-	def get_color(self):
-		return self._color
-
-	def get_services(self):
-		ret = []
-		for serv_list in self._services.values():
-			for service in serv_list:
-				if service not in ret:
-					ret.append(service)
-		return ret
-
-	def get_services_of_type(self, stype):
-		if self._services.has_key(stype):
-			return self._services[stype]
-		return []
-
-	def get_joined_buddies(self):
-		buddies = []
-		for serv_list in self._services.values():
-			for serv in serv_list:
-				owner = serv.get_owner()
-				if owner and not owner in buddies and owner.is_valid():
-					buddies.append(owner)
-		return buddies
-
-	def add_service(self, service):
-		stype = service.get_type()
-		if not self._services.has_key(stype):
-			self._services[stype] = []
-
-		if not self._color:
-			color = service.get_one_property('color')
-			if color:
-				self._color = color
-				self._valid = True
-
-		# Send out the BuddyJoined signal if this is the first
-		# service from the buddy that we've seen
-		buddies = self.get_joined_buddies()
-		serv_owner = service.get_owner()
-		if serv_owner and serv_owner not in buddies and serv_owner.is_valid():
-			self._dbus_helper.BuddyJoined(serv_owner.object_path())
-			serv_owner.add_activity(self)
-
-		if not service in self._services[stype]:
-			self._services[stype].append(service)
-			self._dbus_helper.ServiceAppeared(service.object_path())
-
-	def remove_service(self, service):
-		stype = service.get_type()
-		if not self._services.has_key(stype):
-			return
-		self._services[stype].remove(service)
-		self._dbus_helper.ServiceDisappeared(service.object_path())
-		if len(self._services[stype]) == 0:
-			del self._services[stype]
-
-		# Send out the BuddyLeft signal if this is the last
-		# service from the buddy
-		buddies = self.get_joined_buddies()
-		serv_owner = service.get_owner()
-		if serv_owner and serv_owner not in buddies and serv_owner.is_valid():
-			serv_owner.remove_activity(self)
-			self._dbus_helper.BuddyLeft(serv_owner.object_path())
+    def __init__(self, bus_name, object_id, initial_service):
+        if not initial_service.get_activity_id():
+            raise ValueError("Service must have a valid Activity ID")
+        self._activity_id = initial_service.get_activity_id()
+
+        self._buddies = []
+        self._services = {}    # service type -> list of Services
+        self._color = None
+        self._valid = False
+
+        self._object_id = object_id
+        self._object_path = "/org/laptop/Presence/Activities/%d" % self._object_id
+        self._dbus_helper = ActivityDBusHelper(self, bus_name, self._object_path)
+        
+        self.add_service(initial_service)
+
+    def object_path(self):
+        return dbus.ObjectPath(self._object_path)
+
+    def is_valid(self):
+        """An activity is only valid when it's color is available."""
+        return self._valid
+
+    def get_id(self):
+        return self._activity_id
+
+    def get_color(self):
+        return self._color
+
+    def get_services(self):
+        ret = []
+        for serv_list in self._services.values():
+            for service in serv_list:
+                if service not in ret:
+                    ret.append(service)
+        return ret
+
+    def get_services_of_type(self, stype):
+        if self._services.has_key(stype):
+            return self._services[stype]
+        return []
+
+    def get_joined_buddies(self):
+        buddies = []
+        for serv_list in self._services.values():
+            for serv in serv_list:
+                owner = serv.get_owner()
+                if owner and not owner in buddies and owner.is_valid():
+                    buddies.append(owner)
+        return buddies
+
+    def add_service(self, service):
+        stype = service.get_type()
+        if not self._services.has_key(stype):
+            self._services[stype] = []
+
+        if not self._color:
+            color = service.get_one_property('color')
+            if color:
+                self._color = color
+                self._valid = True
+
+        # Send out the BuddyJoined signal if this is the first
+        # service from the buddy that we've seen
+        buddies = self.get_joined_buddies()
+        serv_owner = service.get_owner()
+        if serv_owner and serv_owner not in buddies and serv_owner.is_valid():
+            self._dbus_helper.BuddyJoined(serv_owner.object_path())
+            serv_owner.add_activity(self)
+
+        if not service in self._services[stype]:
+            self._services[stype].append(service)
+            self._dbus_helper.ServiceAppeared(service.object_path())
+
+    def remove_service(self, service):
+        stype = service.get_type()
+        if not self._services.has_key(stype):
+            return
+        self._services[stype].remove(service)
+        self._dbus_helper.ServiceDisappeared(service.object_path())
+        if len(self._services[stype]) == 0:
+            del self._services[stype]
+
+        # Send out the BuddyLeft signal if this is the last
+        # service from the buddy
+        buddies = self.get_joined_buddies()
+        serv_owner = service.get_owner()
+        if serv_owner and serv_owner not in buddies and serv_owner.is_valid():
+            serv_owner.remove_activity(self)
+            self._dbus_helper.BuddyLeft(serv_owner.object_path())
diff --git a/services/presence/Buddy.py b/services/presence/Buddy.py
index a49b46a..31d8fe1 100644
--- a/services/presence/Buddy.py
+++ b/services/presence/Buddy.py
@@ -30,433 +30,433 @@ _BUDDY_KEY_COLOR = 'color'
 _BUDDY_KEY_CURACT = 'curact'
 
 class NotFoundError(Exception):
-	pass
+    pass
 
 class BuddyDBusHelper(dbus.service.Object):
-	def __init__(self, parent, bus_name, object_path):
-		self._parent = parent
-		self._bus_name = bus_name
-		self._object_path = object_path
-		dbus.service.Object.__init__(self, bus_name, self._object_path)
-
-	@dbus.service.signal(BUDDY_DBUS_INTERFACE,
-						signature="o")
-	def ServiceAppeared(self, object_path):
-		pass
-
-	@dbus.service.signal(BUDDY_DBUS_INTERFACE,
-						signature="o")
-	def ServiceDisappeared(self, object_path):
-		pass
-
-	@dbus.service.signal(BUDDY_DBUS_INTERFACE,
-						signature="")
-	def Disappeared(self):
-		pass
-
-	@dbus.service.signal(BUDDY_DBUS_INTERFACE,
-						signature="ao")
-	def CurrentActivityChanged(self, activities):
-		pass
-
-	@dbus.service.signal(BUDDY_DBUS_INTERFACE,
-						signature="")
-	def IconChanged(self):
-		pass
-
-	@dbus.service.signal(BUDDY_DBUS_INTERFACE,
-						signature="o")
-	def JoinedActivity(self, object_path):
-		pass
-
-	@dbus.service.signal(BUDDY_DBUS_INTERFACE,
-						signature="o")
-	def LeftActivity(self, object_path):
-		pass
-
-	@dbus.service.signal(BUDDY_DBUS_INTERFACE,
-						signature="as")
-	def PropertyChanged(self, prop_list):
-		pass
-
-	@dbus.service.method(BUDDY_DBUS_INTERFACE,
-						in_signature="", out_signature="ay")
-	def getIcon(self):
-		icon = self._parent.get_icon()
-		if not icon:
-			return ""
-		return icon
-
-	@dbus.service.method(BUDDY_DBUS_INTERFACE,
-						in_signature="so", out_signature="o")
-	def getServiceOfType(self, stype, activity_op):
-		activity = None
-		# "/" is the placeholder for None
-		if activity_op != "/":
-			for act in self._parent.get_joined_activities():
-				if act.object_path() == activity_op:
-					activity = act
-			if not activity:
-				raise NotFoundError("Not found")
-
-		service = self._parent.get_service_of_type(stype, activity)
-		if not service:
-			raise NotFoundError("Not found")
-		return service.object_path()
-
-	@dbus.service.method(BUDDY_DBUS_INTERFACE,
-						in_signature="", out_signature="ao")
-	def getJoinedActivities(self):
-		acts = []
-		for act in self._parent.get_joined_activities():
-			acts.append(act.object_path())
-		return acts
-
-	@dbus.service.method(BUDDY_DBUS_INTERFACE,
-						in_signature="", out_signature="a{sv}")
-	def getProperties(self):
-		props = {}
-		props['name'] = self._parent.get_name()
-		addr = self._parent.get_address()
-		if addr:
-			props['ip4_address'] = addr
-		props['owner'] = self._parent.is_owner()
-		color = self._parent.get_color()
-		if color:
-			props[_BUDDY_KEY_COLOR] = self._parent.get_color()
-		return props
-
-	@dbus.service.method(BUDDY_DBUS_INTERFACE,
-						in_signature="", out_signature="o")
-	def getCurrentActivity(self):
-		activity = self._parent.get_current_activity()
-		if not activity:
-			raise NotFoundError()
-		return activity.object_path()
+    def __init__(self, parent, bus_name, object_path):
+        self._parent = parent
+        self._bus_name = bus_name
+        self._object_path = object_path
+        dbus.service.Object.__init__(self, bus_name, self._object_path)
+
+    @dbus.service.signal(BUDDY_DBUS_INTERFACE,
+                        signature="o")
+    def ServiceAppeared(self, object_path):
+        pass
+
+    @dbus.service.signal(BUDDY_DBUS_INTERFACE,
+                        signature="o")
+    def ServiceDisappeared(self, object_path):
+        pass
+
+    @dbus.service.signal(BUDDY_DBUS_INTERFACE,
+                        signature="")
+    def Disappeared(self):
+        pass
+
+    @dbus.service.signal(BUDDY_DBUS_INTERFACE,
+                        signature="ao")
+    def CurrentActivityChanged(self, activities):
+        pass
+
+    @dbus.service.signal(BUDDY_DBUS_INTERFACE,
+                        signature="")
+    def IconChanged(self):
+        pass
+
+    @dbus.service.signal(BUDDY_DBUS_INTERFACE,
+                        signature="o")
+    def JoinedActivity(self, object_path):
+        pass
+
+    @dbus.service.signal(BUDDY_DBUS_INTERFACE,
+                        signature="o")
+    def LeftActivity(self, object_path):
+        pass
+
+    @dbus.service.signal(BUDDY_DBUS_INTERFACE,
+                        signature="as")
+    def PropertyChanged(self, prop_list):
+        pass
+
+    @dbus.service.method(BUDDY_DBUS_INTERFACE,
+                        in_signature="", out_signature="ay")
+    def getIcon(self):
+        icon = self._parent.get_icon()
+        if not icon:
+            return ""
+        return icon
+
+    @dbus.service.method(BUDDY_DBUS_INTERFACE,
+                        in_signature="so", out_signature="o")
+    def getServiceOfType(self, stype, activity_op):
+        activity = None
+        # "/" is the placeholder for None
+        if activity_op != "/":
+            for act in self._parent.get_joined_activities():
+                if act.object_path() == activity_op:
+                    activity = act
+            if not activity:
+                raise NotFoundError("Not found")
+
+        service = self._parent.get_service_of_type(stype, activity)
+        if not service:
+            raise NotFoundError("Not found")
+        return service.object_path()
+
+    @dbus.service.method(BUDDY_DBUS_INTERFACE,
+                        in_signature="", out_signature="ao")
+    def getJoinedActivities(self):
+        acts = []
+        for act in self._parent.get_joined_activities():
+            acts.append(act.object_path())
+        return acts
+
+    @dbus.service.method(BUDDY_DBUS_INTERFACE,
+                        in_signature="", out_signature="a{sv}")
+    def getProperties(self):
+        props = {}
+        props['name'] = self._parent.get_name()
+        addr = self._parent.get_address()
+        if addr:
+            props['ip4_address'] = addr
+        props['owner'] = self._parent.is_owner()
+        color = self._parent.get_color()
+        if color:
+            props[_BUDDY_KEY_COLOR] = self._parent.get_color()
+        return props
+
+    @dbus.service.method(BUDDY_DBUS_INTERFACE,
+                        in_signature="", out_signature="o")
+    def getCurrentActivity(self):
+        activity = self._parent.get_current_activity()
+        if not activity:
+            raise NotFoundError()
+        return activity.object_path()
 
 class Buddy(object):
-	"""Represents another person on the network and keeps track of the
-	activities and resources they make available for sharing."""
-
-	def __init__(self, bus_name, object_id, service, icon_cache):
-		if not bus_name:
-			raise ValueError("DBus bus name must be valid")
-		if not object_id or not isinstance(object_id, int):
-			raise ValueError("object id must be a valid number")
-		# Normal Buddy objects must be created with a valid service,
-		# owner objects do not
-		if not isinstance(self, Owner):
-			if not isinstance(service, Service.Service):
-				raise ValueError("service must be a valid service object")
-
-		self._services = {}
-		self._activities = {}
-
-		self._icon_cache = icon_cache
-
-		self._nick_name = None
-		self._address = None
-		if service is not None:
-			self._nick_name = service.get_name()
-			self._address = service.get_source_address()
-		self._color = None
-		self._current_activity = None
-		self._valid = False
-		self._icon = None
-		self._icon_tries = 0
-
-		self._object_id = object_id
-		self._object_path = BUDDY_DBUS_OBJECT_PATH + str(self._object_id)
-		self._dbus_helper = BuddyDBusHelper(self, bus_name, self._object_path)
-
-		self._buddy_presence_service = None
-		if service is not None:
-			self.add_service(service)
-
-	def object_path(self):
-		return dbus.ObjectPath(self._object_path)
-
-	def _request_buddy_icon_cb(self, result_status, response, user_data):
-		"""Callback when icon request has completed."""
-		from sugar.p2p import network
-		icon = response
-		service = user_data
-		if result_status == network.RESULT_SUCCESS:
-			if icon and len(icon):
-				icon = base64.b64decode(icon)
-				self._set_icon(icon)
-				self._icon_cache.add_icon(icon)
-
-		if (result_status == network.RESULT_FAILED or not icon) and self._icon_tries < 3:
-			self._icon_tries = self._icon_tries + 1
-			if self._icon_tries >= 3:
-				logging.debug("Failed to retrieve buddy icon for '%s'." % self._nick_name)
-			gobject.timeout_add(1000, self._get_buddy_icon, service, True)
-		return False
-
-	def _get_buddy_icon(self, service, retry=False):
-		"""Get the buddy's icon.  Check the cache first, if its
-		not there get the icon from the buddy over the network."""
-		if retry != True:
-			# Only hit the cache once
-			icon_hash = service.get_one_property('icon-hash')
-			if icon_hash is not None:
-				icon = self._icon_cache.get_icon(icon_hash)
-				if icon:
-					logging.debug("%s: icon cache hit for %s." % (self._nick_name, icon_hash))
-					self._set_icon(icon)
-					return False
-			logging.debug("%s: icon cache miss, fetching icon from buddy..." % self._nick_name)
-
-		from sugar.p2p import Stream
-		buddy_stream = Stream.Stream.new_from_service(service, start_reader=False)
-		writer = buddy_stream.new_writer(service)
-		success = writer.custom_request("get_buddy_icon", self._request_buddy_icon_cb, service)
-		if not success:
-			del writer, buddy_stream
-			gobject.timeout_add(1000, self._get_buddy_icon, service, True)
-		return False
-
-	def _get_service_key(self, service):
-		return (service.get_type(), service.get_activity_id())
-
-	def add_service(self, service):
-		"""Adds a new service to this buddy's service list, returning
-		True if the service was successfully added, and False if it was not."""
-		if service.get_name() != self._nick_name:
-			logging.error("Service and buddy nick names doesn't match: " \
-					"%s %s" % (service.get_name(), self._nick_name))
-			return False
-
-		source_addr = service.get_source_address()
-		if source_addr != self._address:
-			logging.error("Service source and buddy address doesn't " \
-					"match: %s %s" % (source_addr, self._address))
-			return False		
-		return self._internal_add_service(service)
-
-	def _internal_add_service(self, service):
-		service_key = self._get_service_key(service)
-		if service_key in self._services.keys():
-			logging.error("Service already known: %s %s" % (service_key[0],
-					service_key[1]))
-			return False
-
-		if service.get_type() == PRESENCE_SERVICE_TYPE and self._buddy_presence_service:
-			# already have a presence service for this buddy
-			logging.debug("!!! Tried to add a buddy presence service when " \
-					"one already existed.")
-			return False
-
-		logging.debug("Buddy %s added service type %s id %s" % (self._nick_name,
-				service.get_type(), service.get_activity_id()))
-		self._services[service_key] = service
-		service.set_owner(self)
-
-		if service.get_type() == PRESENCE_SERVICE_TYPE:
-			self._buddy_presence_service = service
-			# A buddy isn't valid until its official presence
-			# service has been found and resolved
-			self._valid = True
-			self._get_buddy_icon(service)
-			self._color = service.get_one_property(_BUDDY_KEY_COLOR)
-			self._current_activity = service.get_one_property(_BUDDY_KEY_CURACT)
-			# Monitor further buddy property changes, like current activity
-			# and color
-			service.connect('property-changed',
-					self.__buddy_presence_service_property_changed_cb)
-
-		if self._valid:
-			self._dbus_helper.ServiceAppeared(service.object_path())
-		return True
-
-	def __buddy_presence_service_property_changed_cb(self, service, keys):
-		if _BUDDY_KEY_COLOR in keys:
-			new_color = service.get_one_property(_BUDDY_KEY_COLOR)
-			if new_color and self._color != new_color:
-				self._color = new_color
-				self._dbus_helper.PropertyChanged([_BUDDY_KEY_COLOR])
-		if _BUDDY_KEY_CURACT in keys:
-			# Three cases here:
-			# 1) Buddy didn't publish a 'curact' key at all; we do nothing
-			# 2) Buddy published a blank/zero-length 'curact' key; we send
-			#        a current-activity-changed signal for no activity
-			# 3) Buddy published a non-zero-length 'curact' key; we send
-			#        a current-activity-changed signal if we know about the
-			#        activity already, if not we postpone until the activity
-			#        is found on the network and added to the buddy
-			new_curact = service.get_one_property(_BUDDY_KEY_CURACT)
-			if new_curact and self._current_activity != new_curact:
-				if not len(new_curact):
-					new_curact = None
-				self._current_activity = new_curact
-				if self._activities.has_key(self._current_activity):
-					# Case (3) above, valid activity id
-					activity = self._activities[self._current_activity]
-					if activity.is_valid():
-						self._dbus_helper.CurrentActivityChanged([activity.object_path()])
-				elif not self._current_activity:
-					# Case (2) above, no current activity
-					self._dbus_helper.CurrentActivityChanged([])
-
-	def __find_service_by_activity_id(self, actid):
-		for serv in self._services.values():
-			if serv.get_activity_id() == actid:
-				return serv
-		return None
-
-	def add_activity(self, activity):
-		if activity in self._activities.values():
-			return
-		actid = activity.get_id()
-		if not self.__find_service_by_activity_id(actid):
-			raise RuntimeError("Tried to add activity for which we had no service")
-		self._activities[actid] = activity
-		if activity.is_valid():
-			self._dbus_helper.JoinedActivity(activity.object_path())
-
-			# If when we received a current activity update from the buddy,
-			# but didn't know about that activity yet, and now we do know about
-			# it, we need to send out the changed activity signal
-			if actid == self._current_activity:
-				self._dbus_helper.CurrentActivityChanged([activity.object_path()])
-
-	def remove_service(self, service):
-		"""Remove a service from a buddy; ie, the activity was closed
-		or the buddy went away."""
-		if service.get_source_address() != self._address:
-			return
-		if service.get_name() != self._nick_name:
-			return
-
-		if service.get_type() == PRESENCE_SERVICE_TYPE \
-				and self._buddy_presence_service \
-				and service != self._buddy_presence_service:
-			logging.debug("!!! Tried to remove a spurious buddy presence service.")
-			return
-
-		service_key = self._get_service_key(service)
-		if self._services.has_key(service_key):
-			if self._valid:
-				self._dbus_helper.ServiceDisappeared(service.object_path())
-			del self._services[service_key]
-
-		if service.get_type() == PRESENCE_SERVICE_TYPE:
-			self._valid = False
-			self._dbus_helper.Disappeared()
-
-	def remove_activity(self, activity):
-		actid = activity.get_id()
-		if not self._activities.has_key(actid):
-			return
-		del self._activities[actid]
-		if activity.is_valid():
-			self._dbus_helper.LeftActivity(activity.object_path())
-
-		# If we just removed the buddy's current activity,
-		# send out a signal
-		if actid == self._current_activity:
-			self._current_activity = None
-			self._dbus_helper.CurrentActivityChanged([])
-
-	def get_joined_activities(self):
-		acts = []
-		for act in self._activities.values():
-			if act.is_valid():
-				acts.append(act)
-		return acts
-
-	def get_service_of_type(self, stype, activity=None):
-		"""Return a service of a certain type, or None if the buddy
-		doesn't provide that service."""
-		if not stype:
-			raise RuntimeError("Need to specify a service type.")
-
-		if activity and not activity.is_valid():
-			raise RuntimeError("Activity is not yet valid.")
-
-		if activity:
-			key = (stype, activity.get_id())
-		else:
-			key = (stype, None)
-		if self._services.has_key(key):
-			return self._services[key]
-		return None
-
-	def is_valid(self):
-		"""Return whether the buddy is valid or not.  A buddy is
-		not valid until its official presence service has been found
-		and successfully resolved."""
-		return self._valid
-
-	def get_icon(self):
-		"""Return the buddies icon, if any."""
-		return self._icon
-		
-	def get_address(self):
-		return self._address
-
-	def get_name(self):
-		return self._nick_name
-
-	def get_color(self):
-		return self._color
-
-	def get_current_activity(self):
-		if not self._current_activity:
-			return None
-		if not self._activities.has_key(self._current_activity):
-			return None
-		return self._activities[self._current_activity]
-
-	def _set_icon(self, icon):
-		"""Can only set icon for other buddies.  The Owner
-		takes care of setting it's own icon."""
-		if icon != self._icon:
-			self._icon = icon
-			self._dbus_helper.IconChanged()
-
-	def is_owner(self):
-		return False
+    """Represents another person on the network and keeps track of the
+    activities and resources they make available for sharing."""
+
+    def __init__(self, bus_name, object_id, service, icon_cache):
+        if not bus_name:
+            raise ValueError("DBus bus name must be valid")
+        if not object_id or not isinstance(object_id, int):
+            raise ValueError("object id must be a valid number")
+        # Normal Buddy objects must be created with a valid service,
+        # owner objects do not
+        if not isinstance(self, Owner):
+            if not isinstance(service, Service.Service):
+                raise ValueError("service must be a valid service object")
+
+        self._services = {}
+        self._activities = {}
+
+        self._icon_cache = icon_cache
+
+        self._nick_name = None
+        self._address = None
+        if service is not None:
+            self._nick_name = service.get_name()
+            self._address = service.get_source_address()
+        self._color = None
+        self._current_activity = None
+        self._valid = False
+        self._icon = None
+        self._icon_tries = 0
+
+        self._object_id = object_id
+        self._object_path = BUDDY_DBUS_OBJECT_PATH + str(self._object_id)
+        self._dbus_helper = BuddyDBusHelper(self, bus_name, self._object_path)
+
+        self._buddy_presence_service = None
+        if service is not None:
+            self.add_service(service)
+
+    def object_path(self):
+        return dbus.ObjectPath(self._object_path)
+
+    def _request_buddy_icon_cb(self, result_status, response, user_data):
+        """Callback when icon request has completed."""
+        from sugar.p2p import network
+        icon = response
+        service = user_data
+        if result_status == network.RESULT_SUCCESS:
+            if icon and len(icon):
+                icon = base64.b64decode(icon)
+                self._set_icon(icon)
+                self._icon_cache.add_icon(icon)
+
+        if (result_status == network.RESULT_FAILED or not icon) and self._icon_tries < 3:
+            self._icon_tries = self._icon_tries + 1
+            if self._icon_tries >= 3:
+                logging.debug("Failed to retrieve buddy icon for '%s'." % self._nick_name)
+            gobject.timeout_add(1000, self._get_buddy_icon, service, True)
+        return False
+
+    def _get_buddy_icon(self, service, retry=False):
+        """Get the buddy's icon.  Check the cache first, if its
+        not there get the icon from the buddy over the network."""
+        if retry != True:
+            # Only hit the cache once
+            icon_hash = service.get_one_property('icon-hash')
+            if icon_hash is not None:
+                icon = self._icon_cache.get_icon(icon_hash)
+                if icon:
+                    logging.debug("%s: icon cache hit for %s." % (self._nick_name, icon_hash))
+                    self._set_icon(icon)
+                    return False
+            logging.debug("%s: icon cache miss, fetching icon from buddy..." % self._nick_name)
+
+        from sugar.p2p import Stream
+        buddy_stream = Stream.Stream.new_from_service(service, start_reader=False)
+        writer = buddy_stream.new_writer(service)
+        success = writer.custom_request("get_buddy_icon", self._request_buddy_icon_cb, service)
+        if not success:
+            del writer, buddy_stream
+            gobject.timeout_add(1000, self._get_buddy_icon, service, True)
+        return False
+
+    def _get_service_key(self, service):
+        return (service.get_type(), service.get_activity_id())
+
+    def add_service(self, service):
+        """Adds a new service to this buddy's service list, returning
+        True if the service was successfully added, and False if it was not."""
+        if service.get_name() != self._nick_name:
+            logging.error("Service and buddy nick names doesn't match: " \
+                    "%s %s" % (service.get_name(), self._nick_name))
+            return False
+
+        source_addr = service.get_source_address()
+        if source_addr != self._address:
+            logging.error("Service source and buddy address doesn't " \
+                    "match: %s %s" % (source_addr, self._address))
+            return False        
+        return self._internal_add_service(service)
+
+    def _internal_add_service(self, service):
+        service_key = self._get_service_key(service)
+        if service_key in self._services.keys():
+            logging.error("Service already known: %s %s" % (service_key[0],
+                    service_key[1]))
+            return False
+
+        if service.get_type() == PRESENCE_SERVICE_TYPE and self._buddy_presence_service:
+            # already have a presence service for this buddy
+            logging.debug("!!! Tried to add a buddy presence service when " \
+                    "one already existed.")
+            return False
+
+        logging.debug("Buddy %s added service type %s id %s" % (self._nick_name,
+                service.get_type(), service.get_activity_id()))
+        self._services[service_key] = service
+        service.set_owner(self)
+
+        if service.get_type() == PRESENCE_SERVICE_TYPE:
+            self._buddy_presence_service = service
+            # A buddy isn't valid until its official presence
+            # service has been found and resolved
+            self._valid = True
+            self._get_buddy_icon(service)
+            self._color = service.get_one_property(_BUDDY_KEY_COLOR)
+            self._current_activity = service.get_one_property(_BUDDY_KEY_CURACT)
+            # Monitor further buddy property changes, like current activity
+            # and color
+            service.connect('property-changed',
+                    self.__buddy_presence_service_property_changed_cb)
+
+        if self._valid:
+            self._dbus_helper.ServiceAppeared(service.object_path())
+        return True
+
+    def __buddy_presence_service_property_changed_cb(self, service, keys):
+        if _BUDDY_KEY_COLOR in keys:
+            new_color = service.get_one_property(_BUDDY_KEY_COLOR)
+            if new_color and self._color != new_color:
+                self._color = new_color
+                self._dbus_helper.PropertyChanged([_BUDDY_KEY_COLOR])
+        if _BUDDY_KEY_CURACT in keys:
+            # Three cases here:
+            # 1) Buddy didn't publish a 'curact' key at all; we do nothing
+            # 2) Buddy published a blank/zero-length 'curact' key; we send
+            #        a current-activity-changed signal for no activity
+            # 3) Buddy published a non-zero-length 'curact' key; we send
+            #        a current-activity-changed signal if we know about the
+            #        activity already, if not we postpone until the activity
+            #        is found on the network and added to the buddy
+            new_curact = service.get_one_property(_BUDDY_KEY_CURACT)
+            if new_curact and self._current_activity != new_curact:
+                if not len(new_curact):
+                    new_curact = None
+                self._current_activity = new_curact
+                if self._activities.has_key(self._current_activity):
+                    # Case (3) above, valid activity id
+                    activity = self._activities[self._current_activity]
+                    if activity.is_valid():
+                        self._dbus_helper.CurrentActivityChanged([activity.object_path()])
+                elif not self._current_activity:
+                    # Case (2) above, no current activity
+                    self._dbus_helper.CurrentActivityChanged([])
+
+    def __find_service_by_activity_id(self, actid):
+        for serv in self._services.values():
+            if serv.get_activity_id() == actid:
+                return serv
+        return None
+
+    def add_activity(self, activity):
+        if activity in self._activities.values():
+            return
+        actid = activity.get_id()
+        if not self.__find_service_by_activity_id(actid):
+            raise RuntimeError("Tried to add activity for which we had no service")
+        self._activities[actid] = activity
+        if activity.is_valid():
+            self._dbus_helper.JoinedActivity(activity.object_path())
+
+            # If when we received a current activity update from the buddy,
+            # but didn't know about that activity yet, and now we do know about
+            # it, we need to send out the changed activity signal
+            if actid == self._current_activity:
+                self._dbus_helper.CurrentActivityChanged([activity.object_path()])
+
+    def remove_service(self, service):
+        """Remove a service from a buddy; ie, the activity was closed
+        or the buddy went away."""
+        if service.get_source_address() != self._address:
+            return
+        if service.get_name() != self._nick_name:
+            return
+
+        if service.get_type() == PRESENCE_SERVICE_TYPE \
+                and self._buddy_presence_service \
+                and service != self._buddy_presence_service:
+            logging.debug("!!! Tried to remove a spurious buddy presence service.")
+            return
+
+        service_key = self._get_service_key(service)
+        if self._services.has_key(service_key):
+            if self._valid:
+                self._dbus_helper.ServiceDisappeared(service.object_path())
+            del self._services[service_key]
+
+        if service.get_type() == PRESENCE_SERVICE_TYPE:
+            self._valid = False
+            self._dbus_helper.Disappeared()
+
+    def remove_activity(self, activity):
+        actid = activity.get_id()
+        if not self._activities.has_key(actid):
+            return
+        del self._activities[actid]
+        if activity.is_valid():
+            self._dbus_helper.LeftActivity(activity.object_path())
+
+        # If we just removed the buddy's current activity,
+        # send out a signal
+        if actid == self._current_activity:
+            self._current_activity = None
+            self._dbus_helper.CurrentActivityChanged([])
+
+    def get_joined_activities(self):
+        acts = []
+        for act in self._activities.values():
+            if act.is_valid():
+                acts.append(act)
+        return acts
+
+    def get_service_of_type(self, stype, activity=None):
+        """Return a service of a certain type, or None if the buddy
+        doesn't provide that service."""
+        if not stype:
+            raise RuntimeError("Need to specify a service type.")
+
+        if activity and not activity.is_valid():
+            raise RuntimeError("Activity is not yet valid.")
+
+        if activity:
+            key = (stype, activity.get_id())
+        else:
+            key = (stype, None)
+        if self._services.has_key(key):
+            return self._services[key]
+        return None
+
+    def is_valid(self):
+        """Return whether the buddy is valid or not.  A buddy is
+        not valid until its official presence service has been found
+        and successfully resolved."""
+        return self._valid
+
+    def get_icon(self):
+        """Return the buddies icon, if any."""
+        return self._icon
+        
+    def get_address(self):
+        return self._address
+
+    def get_name(self):
+        return self._nick_name
+
+    def get_color(self):
+        return self._color
+
+    def get_current_activity(self):
+        if not self._current_activity:
+            return None
+        if not self._activities.has_key(self._current_activity):
+            return None
+        return self._activities[self._current_activity]
+
+    def _set_icon(self, icon):
+        """Can only set icon for other buddies.  The Owner
+        takes care of setting it's own icon."""
+        if icon != self._icon:
+            self._icon = icon
+            self._dbus_helper.IconChanged()
+
+    def is_owner(self):
+        return False
 
 
 class Owner(Buddy):
-	"""Class representing the owner of the machine.  This is the client
-	portion of the Owner, paired with the server portion in Owner.py."""
-	def __init__(self, ps, bus_name, object_id, icon_cache):
-		Buddy.__init__(self, bus_name, object_id, None, icon_cache)
-		self._nick_name = profile.get_nick_name()
-		self._color = profile.get_color()
-		self._ps = ps
-
-	def add_service(self, service):
-		"""Adds a new service to this buddy's service list, returning
-		True if the service was successfully added, and False if it was not."""
-		if service.get_name() != self._nick_name:
-			logging.error("Service and buddy nick names doesn't match: " \
-					"%s %s" % (service.get_name(), self._nick_name))
-			return False
-
-		# The Owner initially doesn't have an address, so the first
-		# service added to the Owner determines the owner's address
-		source_addr = service.get_source_address()
-		if self._address is None and service.is_local():
-			self._address = source_addr
-			self._dbus_helper.PropertyChanged(['ip4_address'])
-
-		# The owner bypasses address checks and only cares if
-		# avahi says the service is a local service
-		if not service.is_local():
-			logging.error("Cannot add remote service to owner object.")
-			return False
-
-		logging.debug("Adding owner service %s.%s at %s:%d." % (service.get_name(),
-				service.get_type(), service.get_source_address(),
-				service.get_port()))
-		return self._internal_add_service(service)
-
-	def is_owner(self):
-		return True
+    """Class representing the owner of the machine.  This is the client
+    portion of the Owner, paired with the server portion in Owner.py."""
+    def __init__(self, ps, bus_name, object_id, icon_cache):
+        Buddy.__init__(self, bus_name, object_id, None, icon_cache)
+        self._nick_name = profile.get_nick_name()
+        self._color = profile.get_color()
+        self._ps = ps
+
+    def add_service(self, service):
+        """Adds a new service to this buddy's service list, returning
+        True if the service was successfully added, and False if it was not."""
+        if service.get_name() != self._nick_name:
+            logging.error("Service and buddy nick names doesn't match: " \
+                    "%s %s" % (service.get_name(), self._nick_name))
+            return False
+
+        # The Owner initially doesn't have an address, so the first
+        # service added to the Owner determines the owner's address
+        source_addr = service.get_source_address()
+        if self._address is None and service.is_local():
+            self._address = source_addr
+            self._dbus_helper.PropertyChanged(['ip4_address'])
+
+        # The owner bypasses address checks and only cares if
+        # avahi says the service is a local service
+        if not service.is_local():
+            logging.error("Cannot add remote service to owner object.")
+            return False
+
+        logging.debug("Adding owner service %s.%s at %s:%d." % (service.get_name(),
+                service.get_type(), service.get_source_address(),
+                service.get_port()))
+        return self._internal_add_service(service)
+
+    def is_owner(self):
+        return True
 
 
 #################################################################
@@ -468,62 +468,62 @@ import Service
 
 __objid_seq = 0
 def _next_objid():
-	global __objid_seq
-	__objid_seq = __objid_seq + 1
-	return __objid_seq
+    global __objid_seq
+    __objid_seq = __objid_seq + 1
+    return __objid_seq
 
 
 class BuddyTestCase(unittest.TestCase):
-	_DEF_NAME = u"Tommy"
-	_DEF_STYPE = unicode(PRESENCE_SERVICE_TYPE)
-	_DEF_DOMAIN = u"local"
-	_DEF_ADDRESS = u"1.1.1.1"
-	_DEF_PORT = 1234
-
-	def __init__(self, name):
-		self._bus = dbus.SessionBus()
-		self._bus_name = dbus.service.BusName('org.laptop.Presence', bus=self._bus)		
-		unittest.TestCase.__init__(self, name)
-
-	def __del__(self):
-		del self._bus_name
-		del self._bus
-
-	def _test_init_fail(self, service, fail_msg):
-		"""Test something we expect to fail."""
-		try:
-			objid = _next_objid()
-			buddy = Buddy(self._bus_name, objid, service, owner=False)
-		except ValueError, exc:
-			pass
-		else:
-			self.fail("expected a ValueError for %s." % fail_msg)
-
-	def testService(self):
-		service = None
-		self._test_init_fail(service, "invalid service")
-
-	def testGoodInit(self):
-		objid = _next_objid()
-		service = Service.Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN,
-				self._DEF_ADDRESS, self._DEF_PORT)
-		objid = _next_objid()
-		buddy = Buddy(self._bus_name, objid, service)
-		assert buddy.get_name() == self._DEF_NAME, "buddy name wasn't correct after init."
-		assert buddy.get_address() == self._DEF_ADDRESS, "buddy address wasn't correct after init."
-		assert buddy.object_path() == BUDDY_DBUS_OBJECT_PATH + str(objid)
-
-	def addToSuite(suite):
-		suite.addTest(BuddyTestCase("testService"))
-		suite.addTest(BuddyTestCase("testGoodInit"))
-	addToSuite = staticmethod(addToSuite)
+    _DEF_NAME = u"Tommy"
+    _DEF_STYPE = unicode(PRESENCE_SERVICE_TYPE)
+    _DEF_DOMAIN = u"local"
+    _DEF_ADDRESS = u"1.1.1.1"
+    _DEF_PORT = 1234
+
+    def __init__(self, name):
+        self._bus = dbus.SessionBus()
+        self._bus_name = dbus.service.BusName('org.laptop.Presence', bus=self._bus)        
+        unittest.TestCase.__init__(self, name)
+
+    def __del__(self):
+        del self._bus_name
+        del self._bus
+
+    def _test_init_fail(self, service, fail_msg):
+        """Test something we expect to fail."""
+        try:
+            objid = _next_objid()
+            buddy = Buddy(self._bus_name, objid, service, owner=False)
+        except ValueError, exc:
+            pass
+        else:
+            self.fail("expected a ValueError for %s." % fail_msg)
+
+    def testService(self):
+        service = None
+        self._test_init_fail(service, "invalid service")
+
+    def testGoodInit(self):
+        objid = _next_objid()
+        service = Service.Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN,
+                self._DEF_ADDRESS, self._DEF_PORT)
+        objid = _next_objid()
+        buddy = Buddy(self._bus_name, objid, service)
+        assert buddy.get_name() == self._DEF_NAME, "buddy name wasn't correct after init."
+        assert buddy.get_address() == self._DEF_ADDRESS, "buddy address wasn't correct after init."
+        assert buddy.object_path() == BUDDY_DBUS_OBJECT_PATH + str(objid)
+
+    def addToSuite(suite):
+        suite.addTest(BuddyTestCase("testService"))
+        suite.addTest(BuddyTestCase("testGoodInit"))
+    addToSuite = staticmethod(addToSuite)
 
 
 def main():
-	suite = unittest.TestSuite()
-	BuddyTestCase.addToSuite(suite)
-	runner = unittest.TextTestRunner()
-	runner.run(suite)
+    suite = unittest.TestSuite()
+    BuddyTestCase.addToSuite(suite)
+    runner = unittest.TextTestRunner()
+    runner.run(suite)
 
 if __name__ == "__main__":
-	main()
+    main()
diff --git a/services/presence/BuddyIconCache.py b/services/presence/BuddyIconCache.py
index 643116f..7f9952a 100644
--- a/services/presence/BuddyIconCache.py
+++ b/services/presence/BuddyIconCache.py
@@ -19,59 +19,59 @@ from sugar import env
 from sugar import util
 
 class BuddyIconCache(object):
-	"""Caches icons on disk and finds them based on md5 hash."""
-	def __init__(self):
-		ppath = env.get_profile_path()
-		self._cachepath = os.path.join(ppath, "cache", "buddy-icons")
-		if not os.path.exists(self._cachepath):
-			os.makedirs(self._cachepath)
+    """Caches icons on disk and finds them based on md5 hash."""
+    def __init__(self):
+        ppath = env.get_profile_path()
+        self._cachepath = os.path.join(ppath, "cache", "buddy-icons")
+        if not os.path.exists(self._cachepath):
+            os.makedirs(self._cachepath)
 
-		self._cache = {}
+        self._cache = {}
 
-		# Read all cached icons and their sums
-		for fname in os.listdir(self._cachepath):
-			m = md5.new()
-			data = self._get_icon_data(fname)
-			if len(data) == 0:
-				continue
-			m.update(data)
-			printable_hash = util.printable_hash(m.digest())
-			self._cache[printable_hash] = fname
-			del m
+        # Read all cached icons and their sums
+        for fname in os.listdir(self._cachepath):
+            m = md5.new()
+            data = self._get_icon_data(fname)
+            if len(data) == 0:
+                continue
+            m.update(data)
+            printable_hash = util.printable_hash(m.digest())
+            self._cache[printable_hash] = fname
+            del m
 
-	def _get_icon_data(self, fname):
-		fd = open(os.path.join(self._cachepath, fname), "r")
-		data = fd.read()
-		fd.close()
-		del fd
-		return data
+    def _get_icon_data(self, fname):
+        fd = open(os.path.join(self._cachepath, fname), "r")
+        data = fd.read()
+        fd.close()
+        del fd
+        return data
 
-	def get_icon(self, printable_hash):
-		if not isinstance(printable_hash, unicode):
-			raise RuntimeError("printable_hash must be a unicode string.")
-		try:
-			fname = self._cache[printable_hash]
-			return self._get_icon_data(fname)
-		except KeyError:
-			pass
-		return None
+    def get_icon(self, printable_hash):
+        if not isinstance(printable_hash, unicode):
+            raise RuntimeError("printable_hash must be a unicode string.")
+        try:
+            fname = self._cache[printable_hash]
+            return self._get_icon_data(fname)
+        except KeyError:
+            pass
+        return None
 
-	def add_icon(self, icon_data):
-		if len(icon_data) == 0:
-			return
+    def add_icon(self, icon_data):
+        if len(icon_data) == 0:
+            return
 
-		m = md5.new()
-		m.update(icon_data)
-		printable_hash = util.printable_hash(m.digest())
-		if self._cache.has_key(printable_hash):
-			del m
-			return
+        m = md5.new()
+        m.update(icon_data)
+        printable_hash = util.printable_hash(m.digest())
+        if self._cache.has_key(printable_hash):
+            del m
+            return
 
-		# Write the icon to disk and add an entry to our cache for it
-		m.update(time.asctime())
-		fname = util.printable_hash(m.digest())
-		fd = open(os.path.join(self._cachepath, fname), "w")
-		fd.write(icon_data)
-		fd.close()
-		self._cache[printable_hash] = fname
-		del m
+        # Write the icon to disk and add an entry to our cache for it
+        m.update(time.asctime())
+        fname = util.printable_hash(m.digest())
+        fd = open(os.path.join(self._cachepath, fname), "w")
+        fd.write(icon_data)
+        fd.close()
+        self._cache[printable_hash] = fname
+        del m
diff --git a/services/presence/PresenceService.py b/services/presence/PresenceService.py
index 6399a7b..5f8c7a4 100644
--- a/services/presence/PresenceService.py
+++ b/services/presence/PresenceService.py
@@ -30,103 +30,103 @@ _SA_UNRESOLVED = 0
 _SA_RESOLVE_PENDING = 1
 _SA_RESOLVED = 2
 class ServiceAdv(object):
-	"""Wrapper class to track services from Avahi."""
-	def __init__(self, interface, protocol, name, stype, domain, local):
-		self._interface = interface
-		self._protocol = protocol
-		if not isinstance(name, unicode):
-			raise ValueError("service advertisement name must be unicode.")
-		self._name = name
-		if not isinstance(stype, unicode):
-			raise ValueError("service advertisement type must be unicode.")
-		self._stype = stype
-		if not isinstance(domain, unicode):
-			raise ValueError("service advertisement domain must be unicode.")
-		self._domain = domain
-		self._service = None
-		if not isinstance(local, bool):
-			raise ValueError("local must be a bool.")
-		self._local = local
-		self._state = _SA_UNRESOLVED
-		self._resolver = None
-		self._resolv_tries = 0
-
-	def __del__(self):
-		if self._resolver:
-			del self._resolver
-
-	def interface(self):
-		return self._interface
-	def protocol(self):
-		return self._protocol
-	def name(self):
-		return self._name
-	def stype(self):
-		return self._stype
-	def domain(self):
-		return self._domain
-	def is_local(self):
-		return self._local
-	def resolv_tries(self):
-		return self._resolv_tries
-	def inc_resolv_tries(self):
-		self._resolv_tries += 1
-	def service(self):
-		return self._service
-	def set_service(self, service):
-		if not isinstance(service, Service.Service):
-			raise ValueError("must be a valid service.")
-		if service != self._service:
-			self._service = service
-	def resolver(self):
-		return self._resolver
-	def set_resolver(self, resolver):
-		if resolver and not isinstance(resolver, dbus.Interface):
-			raise ValueError("'resolver' must be a valid dbus object")
-		if not resolver and self._resolver:
-			del self._resolver
-		self._resolver = resolver
-	def state(self):
-		return self._state
-	def set_state(self, state):
-		if state == _SA_RESOLVE_PENDING:
-			if self._state == _SA_RESOLVED:
-				raise ValueError("Can't reset to resolve pending from resolved.")
-		if state == _SA_UNRESOLVED:
-			self._resolv_tries = 0
-		self._state = state
+    """Wrapper class to track services from Avahi."""
+    def __init__(self, interface, protocol, name, stype, domain, local):
+        self._interface = interface
+        self._protocol = protocol
+        if not isinstance(name, unicode):
+            raise ValueError("service advertisement name must be unicode.")
+        self._name = name
+        if not isinstance(stype, unicode):
+            raise ValueError("service advertisement type must be unicode.")
+        self._stype = stype
+        if not isinstance(domain, unicode):
+            raise ValueError("service advertisement domain must be unicode.")
+        self._domain = domain
+        self._service = None
+        if not isinstance(local, bool):
+            raise ValueError("local must be a bool.")
+        self._local = local
+        self._state = _SA_UNRESOLVED
+        self._resolver = None
+        self._resolv_tries = 0
+
+    def __del__(self):
+        if self._resolver:
+            del self._resolver
+
+    def interface(self):
+        return self._interface
+    def protocol(self):
+        return self._protocol
+    def name(self):
+        return self._name
+    def stype(self):
+        return self._stype
+    def domain(self):
+        return self._domain
+    def is_local(self):
+        return self._local
+    def resolv_tries(self):
+        return self._resolv_tries
+    def inc_resolv_tries(self):
+        self._resolv_tries += 1
+    def service(self):
+        return self._service
+    def set_service(self, service):
+        if not isinstance(service, Service.Service):
+            raise ValueError("must be a valid service.")
+        if service != self._service:
+            self._service = service
+    def resolver(self):
+        return self._resolver
+    def set_resolver(self, resolver):
+        if resolver and not isinstance(resolver, dbus.Interface):
+            raise ValueError("'resolver' must be a valid dbus object")
+        if not resolver and self._resolver:
+            del self._resolver
+        self._resolver = resolver
+    def state(self):
+        return self._state
+    def set_state(self, state):
+        if state == _SA_RESOLVE_PENDING:
+            if self._state == _SA_RESOLVED:
+                raise ValueError("Can't reset to resolve pending from resolved.")
+        if state == _SA_UNRESOLVED:
+            self._resolv_tries = 0
+        self._state = state
 
 class RegisteredServiceType(object):
-	def __init__(self, stype):
-		self._stype = stype
-		self._refcount = 1
+    def __init__(self, stype):
+        self._stype = stype
+        self._refcount = 1
 
-	def get_type(self):
-		return self._stype
+    def get_type(self):
+        return self._stype
 
-	def ref(self):
-		self._refcount += 1
+    def ref(self):
+        self._refcount += 1
 
-	def unref(self):
-		self._refcount -= 1
-		return self._refcount
+    def unref(self):
+        self._refcount -= 1
+        return self._refcount
 
 def _txt_to_dict(txt):
-	"""Convert an avahi-returned TXT record formatted
-	as nested arrays of integers (from dbus) into a dict
-	of key/value string pairs."""
-	prop_dict = {}
-	props = avahi.txt_array_to_string_array(txt)
-	for item in props:
-		key = value = None
-		if '=' not in item:
-			# No = means a boolean value of true
-			key = item
-			value = True
-		else:
-			(key, value) = item.split('=', 1)
-		prop_dict[key] = value
-	return prop_dict
+    """Convert an avahi-returned TXT record formatted
+    as nested arrays of integers (from dbus) into a dict
+    of key/value string pairs."""
+    prop_dict = {}
+    props = avahi.txt_array_to_string_array(txt)
+    for item in props:
+        key = value = None
+        if '=' not in item:
+            # No = means a boolean value of true
+            key = item
+            value = True
+        else:
+            (key, value) = item.split('=', 1)
+        prop_dict[key] = value
+    return prop_dict
 
 
 _PRESENCE_SERVICE = "org.laptop.Presence"
@@ -134,731 +134,731 @@ _PRESENCE_DBUS_INTERFACE = "org.laptop.Presence"
 _PRESENCE_OBJECT_PATH = "/org/laptop/Presence"
 
 class NotFoundError(Exception):
-	pass
+    pass
 
 class PresenceServiceDBusHelper(dbus.service.Object):
-	def __init__(self, parent, bus_name):
-		self._parent = parent
-		self._bus_name = bus_name
-		dbus.service.Object.__init__(self, bus_name, _PRESENCE_OBJECT_PATH)
-
-	@dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
-						signature="o")
-	def BuddyAppeared(self, object_path):
-		pass
-
-	@dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
-						signature="o")
-	def BuddyDisappeared(self, object_path):
-		pass
-
-	@dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
-						signature="o")
-	def ServiceAppeared(self, object_path):
-		pass
-
-	@dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
-						signature="o")
-	def ServiceDisappeared(self, object_path):
-		pass
-
-	@dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
-						signature="o")
-	def ActivityAppeared(self, object_path):
-		pass
-
-	@dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
-						signature="o")
-	def ActivityDisappeared(self, object_path):
-		pass
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
-						in_signature="", out_signature="ao")
-	def getServices(self):
-		ret = []
-		for serv in self._parent.get_services():
-			ret.append(serv.object_path())
-		return ret
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
-						in_signature="s", out_signature="ao")
-	def getServicesOfType(self, stype):
-		ret = []
-		for serv in self._parent.get_services_of_type(stype):
-			ret.append(serv.object_path())
-		return ret
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
-						in_signature="", out_signature="ao")
-	def getActivities(self):
-		ret = []
-		for act in self._parent.get_activities():
-			ret.append(act.object_path())
-		return ret
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
-						in_signature="s", out_signature="o")
-	def getActivity(self, actid):
-		act = self._parent.get_activity(actid)
-		if not act:
-			raise NotFoundError("Not found")
-		return act.object_path()
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
-						in_signature="", out_signature="ao")
-	def getBuddies(self):
-		ret = []
-		for buddy in self._parent.get_buddies():
-			ret.append(buddy.object_path())
-		return ret
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
-						in_signature="s", out_signature="o")
-	def getBuddyByName(self, name):
-		buddy = self._parent.get_buddy_by_name(name)
-		if not buddy:
-			raise NotFoundError("Not found")
-		return buddy.object_path()
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
-						in_signature="s", out_signature="o")
-	def getBuddyByAddress(self, addr):
-		buddy = self._parent.get_buddy_by_address(addr)
-		if not buddy:
-			raise NotFoundError("Not found")
-		return buddy.object_path()
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
-						in_signature="", out_signature="o")
-	def getOwner(self):
-		owner = self._parent.get_owner()
-		if not owner:
-			raise NotFoundError("Not found")
-		return owner.object_path()
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
-						in_signature="os", out_signature="o",
-						sender_keyword="sender")
-	def joinActivity(self, activity_op, stype, sender):
-		found_activity = None
-		acts = self._parent.get_activities()
-		for act in acts:
-			if act.object_path() == activity_op:
-				found_activity = act
-				break
-		if not found_activity:
-			raise NotFoundError("The activity %s was not found." % activity_op)
-		return self._parent.join_activity(found_activity, stype, sender)
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
-						in_signature="ssa{ss}sis", out_signature="o",
-						sender_keyword="sender")
-	def shareActivity(self, activity_id, stype, properties, address, port,
-			domain, sender=None):
-		if not len(address):
-			address = None
-		service = self._parent.share_activity(activity_id, stype, properties, address,
-				port, domain, sender)
-		return service.object_path()
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
-						in_signature="ssa{ss}sis", out_signature="o",
-						sender_keyword="sender")
-	def registerService(self, name, stype, properties, address, port, domain,
-			sender=None):
-		if not len(address):
-			address = None
-		service = self._parent.register_service(name, stype, properties, address,
-				port, domain, sender)
-		return service.object_path()
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
-						in_signature="o", out_signature="",
-						sender_keyword="sender")
-	def unregisterService(self, service_op, sender):
-		found_serv = None
-		services = self._parent.get_services()
-		for serv in services:
-			if serv.object_path() == service_op:
-				found_serv = serv
-				break
-		if not found_serv:
-			raise NotFoundError("The service %s was not found." % service_op)
-		return self._parent.unregister_service(found_serv, sender)
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
-						in_signature="s", out_signature="")
-	def registerServiceType(self, stype):
-		self._parent.register_service_type(stype)
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE,
-						in_signature="s", out_signature="")
-	def unregisterServiceType(self, stype):
-		self._parent.unregister_service_type(stype)
-
-	@dbus.service.method(_PRESENCE_DBUS_INTERFACE)
-	def start(self):
-		self._parent.start()
+    def __init__(self, parent, bus_name):
+        self._parent = parent
+        self._bus_name = bus_name
+        dbus.service.Object.__init__(self, bus_name, _PRESENCE_OBJECT_PATH)
+
+    @dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
+                        signature="o")
+    def BuddyAppeared(self, object_path):
+        pass
+
+    @dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
+                        signature="o")
+    def BuddyDisappeared(self, object_path):
+        pass
+
+    @dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
+                        signature="o")
+    def ServiceAppeared(self, object_path):
+        pass
+
+    @dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
+                        signature="o")
+    def ServiceDisappeared(self, object_path):
+        pass
+
+    @dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
+                        signature="o")
+    def ActivityAppeared(self, object_path):
+        pass
+
+    @dbus.service.signal(_PRESENCE_DBUS_INTERFACE,
+                        signature="o")
+    def ActivityDisappeared(self, object_path):
+        pass
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+                        in_signature="", out_signature="ao")
+    def getServices(self):
+        ret = []
+        for serv in self._parent.get_services():
+            ret.append(serv.object_path())
+        return ret
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+                        in_signature="s", out_signature="ao")
+    def getServicesOfType(self, stype):
+        ret = []
+        for serv in self._parent.get_services_of_type(stype):
+            ret.append(serv.object_path())
+        return ret
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+                        in_signature="", out_signature="ao")
+    def getActivities(self):
+        ret = []
+        for act in self._parent.get_activities():
+            ret.append(act.object_path())
+        return ret
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+                        in_signature="s", out_signature="o")
+    def getActivity(self, actid):
+        act = self._parent.get_activity(actid)
+        if not act:
+            raise NotFoundError("Not found")
+        return act.object_path()
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+                        in_signature="", out_signature="ao")
+    def getBuddies(self):
+        ret = []
+        for buddy in self._parent.get_buddies():
+            ret.append(buddy.object_path())
+        return ret
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+                        in_signature="s", out_signature="o")
+    def getBuddyByName(self, name):
+        buddy = self._parent.get_buddy_by_name(name)
+        if not buddy:
+            raise NotFoundError("Not found")
+        return buddy.object_path()
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+                        in_signature="s", out_signature="o")
+    def getBuddyByAddress(self, addr):
+        buddy = self._parent.get_buddy_by_address(addr)
+        if not buddy:
+            raise NotFoundError("Not found")
+        return buddy.object_path()
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+                        in_signature="", out_signature="o")
+    def getOwner(self):
+        owner = self._parent.get_owner()
+        if not owner:
+            raise NotFoundError("Not found")
+        return owner.object_path()
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+                        in_signature="os", out_signature="o",
+                        sender_keyword="sender")
+    def joinActivity(self, activity_op, stype, sender):
+        found_activity = None
+        acts = self._parent.get_activities()
+        for act in acts:
+            if act.object_path() == activity_op:
+                found_activity = act
+                break
+        if not found_activity:
+            raise NotFoundError("The activity %s was not found." % activity_op)
+        return self._parent.join_activity(found_activity, stype, sender)
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+                        in_signature="ssa{ss}sis", out_signature="o",
+                        sender_keyword="sender")
+    def shareActivity(self, activity_id, stype, properties, address, port,
+            domain, sender=None):
+        if not len(address):
+            address = None
+        service = self._parent.share_activity(activity_id, stype, properties, address,
+                port, domain, sender)
+        return service.object_path()
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+                        in_signature="ssa{ss}sis", out_signature="o",
+                        sender_keyword="sender")
+    def registerService(self, name, stype, properties, address, port, domain,
+            sender=None):
+        if not len(address):
+            address = None
+        service = self._parent.register_service(name, stype, properties, address,
+                port, domain, sender)
+        return service.object_path()
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+                        in_signature="o", out_signature="",
+                        sender_keyword="sender")
+    def unregisterService(self, service_op, sender):
+        found_serv = None
+        services = self._parent.get_services()
+        for serv in services:
+            if serv.object_path() == service_op:
+                found_serv = serv
+                break
+        if not found_serv:
+            raise NotFoundError("The service %s was not found." % service_op)
+        return self._parent.unregister_service(found_serv, sender)
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+                        in_signature="s", out_signature="")
+    def registerServiceType(self, stype):
+        self._parent.register_service_type(stype)
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE,
+                        in_signature="s", out_signature="")
+    def unregisterServiceType(self, stype):
+        self._parent.unregister_service_type(stype)
+
+    @dbus.service.method(_PRESENCE_DBUS_INTERFACE)
+    def start(self):
+        self._parent.start()
 
 class PresenceService(object):
-	def __init__(self):
-		# interface -> IP address: interfaces we've gotten events on so far
-		self._started = False
-		self._local_addrs = {}
-
-		self._next_object_id = 0
-
-		self._buddies = {} 		# nick -> Buddy
-		self._services = {}		# (name, type) -> Service
-		self._activities = {}	# activity id -> Activity
-
-		# Keep track of stuff we're already browsing
-		self._service_type_browsers = {}
-		self._service_browsers = {}
-
-		# Resolved service list
-		self._service_advs = []
-
-		# Service types we care about resolving
-		self._registered_service_types = []
-
-		# Set up the dbus service we provide
-		self._session_bus = dbus.SessionBus()
-		self._bus_name = dbus.service.BusName(_PRESENCE_SERVICE, bus=self._session_bus)		
-		self._dbus_helper = PresenceServiceDBusHelper(self, self._bus_name)
-
-		self._icon_cache = BuddyIconCache.BuddyIconCache()
-
-		# Our owner object
-		if profile.get_nick_name():
-			objid = self._get_next_object_id()
-			self._owner = Buddy.Owner(self, self._bus_name,
-									  objid, self._icon_cache)
-			self._buddies[self._owner.get_name()] = self._owner
-		else:
-			self._owner = None
-
-	def start(self):
-		if self._started:
-			return
-		self._started = True
-
-		# Connect to Avahi for mDNS stuff
-		self._system_bus = dbus.SystemBus()
-		self._mdns_service = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME,
-				avahi.DBUS_PATH_SERVER), avahi.DBUS_INTERFACE_SERVER)
-
-		# Always browse .local
-		self._new_domain_cb(avahi.IF_UNSPEC, avahi.PROTO_INET, "local")
-
-		# Connect to Avahi and start looking for stuff
-		domain_browser = self._mdns_service.DomainBrowserNew(avahi.IF_UNSPEC, avahi.PROTO_INET,
-						"", avahi.DOMAIN_BROWSER_BROWSE, dbus.UInt32(0))
-		db = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, domain_browser), avahi.DBUS_INTERFACE_DOMAIN_BROWSER)
-		db.connect_to_signal('ItemNew', self._new_domain_cb_glue)
-
-	def _get_next_object_id(self):
-		"""Increment and return the object ID counter."""
-		self._next_object_id = self._next_object_id + 1
-		return self._next_object_id
-
-	def get_services(self):
-		return self._services.values()
-
-	def get_services_of_type(self, stype):
-		ret = []
-		for serv in self._services.values():
-			if serv.get_type() == stype:
-				ret.append(serv)
-		return ret
-
-	def get_activities(self):
-		# Only return valid activities
-		ret = []
-		for act in self._activities.values():
-			if act.is_valid():
-				ret.append(act)
-		return ret
-
-	def get_activity(self, actid):
-		if self._activities.has_key(actid):
-			act = self._activities[actid]
-			if act.is_valid():
-				return act
-		return None
-
-	def get_buddies(self):
-		buddies = []
-		for buddy in self._buddies.values():
-			if buddy.is_valid():
-				buddies.append(buddy)
-		return buddies
-
-	def get_buddy_by_name(self, name):
-		if self._buddies.has_key(name):
-			if self._buddies[name].is_valid():
-				return self._buddies[name]
-		return None
-
-	def get_buddy_by_address(self, address):
-		for buddy in self._buddies.values():
-			if buddy.get_address() == address and buddy.is_valid():
-				return buddy
-		return None
-
-	def get_owner(self):
-		return self._owner
-
-	def _find_service_adv(self, interface=None, protocol=None, name=None,
-			stype=None, domain=None, local=None):
-		"""Search a list of service advertisements for ones matching
-		certain criteria."""
-		adv_list = []
-		for adv in self._service_advs:
-			if interface and adv.interface() != interface:
-				continue
-			if protocol and adv.protocol() != protocol:
-				continue
-			if name and adv.name() != name:
-				continue
-			if stype and adv.stype() != stype:
-				continue
-			if domain and adv.domain() != domain:
-				continue
-			if local is not None and adv.is_local() != local:
-				continue
-			adv_list.append(adv)
-		return adv_list
-
-	def _find_registered_service_type(self, stype):
-		for item in self._registered_service_types:
-			if item.get_type() == stype:
-				return item
-		return None
-
-	def _handle_new_service_for_buddy(self, service, local):
-		"""Deal with a new discovered service object."""
-		# Once a service is resolved, we match it up to an existing buddy,
-		# or create a new Buddy if this is the first service known about the buddy
-		buddy_was_valid = False
-		name = service.get_name()
-		buddy = None
-		try:
-			buddy = self._buddies[name]
-			buddy_was_valid = buddy.is_valid()
-			service_added = buddy.add_service(service)
-			if service_added:
-				self._dbus_helper.ServiceAppeared(service.object_path())
-		except KeyError:
-			source_addr = service.get_source_address()
-			objid = self._get_next_object_id()
-			buddy = Buddy.Buddy(self._bus_name, objid, service, self._icon_cache)
-			self._buddies[name] = buddy
-			self._dbus_helper.ServiceAppeared(service.object_path())
-		if not buddy_was_valid and buddy.is_valid():
-			self._dbus_helper.BuddyAppeared(buddy.object_path())
-		return buddy
-
-	def _handle_new_activity_service(self, service):
-		# If the serivce is an activity service, merge it into our activities list
-		actid = service.get_activity_id()
-		if not actid:
-			return
-		activity = None
-		was_valid = False
-		if not self._activities.has_key(actid):
-			objid = self._get_next_object_id()
-			activity = Activity.Activity(self._bus_name, objid, service)
-			self._activities[actid] = activity
-		else:
-			activity = self._activities[actid]
-			was_valid = activity.is_valid()
-
-		if activity:
-			activity.add_service(service)
-
-			# Add the activity to its buddy
-			# FIXME: use something other than name to attribute to buddy
-			try:
-				buddy = self._buddies[service.get_name()]
-				buddy.add_activity(activity)
-			except KeyError:
-				pass		
-
-		if not was_valid and activity.is_valid():
-			self._dbus_helper.ActivityAppeared(activity.object_path())
-
-	def _handle_remove_activity_service(self, service):
-		actid = service.get_activity_id()
-		if not actid:
-			return
-		if not self._activities.has_key(actid):
-			return
-
-		activity = self._activities[actid]
-
-		activity.remove_service(service)
-		if len(activity.get_services()) == 0:
-			# Remove the activity from its buddy
-			# FIXME: use something other than name to attribute to buddy
-			try:
-				buddy = self._buddies[service.get_name()]
-				buddy.remove_activity(activity)
-			except KeyError:
-				pass		
-
-			# Kill the activity
-			self._dbus_helper.ActivityDisappeared(activity.object_path())
-			del self._activities[actid]
-
-	def _service_resolved_cb(self, adv, interface, protocol, full_name,
-			stype, domain, host, aprotocol, address, port, txt, flags,
-			updated):
-		"""When the service discovery finally gets here, we've got enough
-		information about the service to assign it to a buddy."""
-		if updated == False:
-			logging.debug("Resolved service '%s' type '%s' domain '%s' to " \
-					" %s:%s" % (full_name, stype, domain, address, port))
-
-		if not adv in self._service_advs:
-			return False
-		if adv.state() != _SA_RESOLVED:
-			return False
-
-		# See if we know about this service already
-		service = None
-		key = (full_name, stype)
-		props = _txt_to_dict(txt)
-		if not self._services.has_key(key):
-			objid = self._get_next_object_id()
-			service = Service.Service(self._bus_name, objid, name=full_name,
-					stype=stype, domain=domain, address=address, port=port,
-					properties=props, source_address=address)
-			self._services[key] = service
-		else:
-			# Already tracking this service; either:
-			# a) we were the one that shared it in the first place,
-			#     and therefore the source address would not have
-			#     been set yet
-			# b) the service has been updated
-			service = self._services[key]
-			if not service.get_source_address():
-				service.set_source_address(address)
-			if not service.get_address():
-				service.set_address(address)
-
-		adv.set_service(service)
-
-		if service and updated:
-			service.set_properties(props, from_network=True)
-			return False
-
-		# Merge the service into our buddy and activity lists, if needed
-		buddy = self._handle_new_service_for_buddy(service, adv.is_local())
-		if buddy and service.get_activity_id():
-			self._handle_new_activity_service(service)
-
-		return False
-
-	def _service_resolved_cb_glue(self, adv, interface, protocol, name,
-			stype, domain, host, aprotocol, address, port, txt, flags):
-		# Avahi doesn't flag updates to existing services, so we have
-		# to determine that here
-		updated = False
-		if adv.state() == _SA_RESOLVED:
-			updated = True
-
-		adv.set_state(_SA_RESOLVED)
-		gobject.idle_add(self._service_resolved_cb, adv, interface,
-				protocol, name, stype, domain, host, aprotocol, address,
-				port, txt, flags, updated)
-
-	def _service_resolved_failure_cb(self, adv, err):
-		retried = False
-		adv.set_resolver(None)
-		if adv.stype() == Buddy.PRESENCE_SERVICE_TYPE:
-			# Retry the presence service type a few times
-			if adv.resolv_tries() < 4:
-				adv.set_state(_SA_RESOLVE_PENDING)
-				gobject.timeout_add(250, self._resolve_service, adv)
-				retried = True
-				logging.error("Retrying resolution of service %s.%s: %s" % (adv.name(),
-					adv.stype(), err))
-
-		if not retried:
-			logging.error("Error resolving service %s.%s: %s" % (adv.name(),
-					adv.stype(), err))
-			adv.set_state(_SA_UNRESOLVED)
-
-	def _resolve_service(self, adv):
-		"""Resolve and lookup a ZeroConf service to obtain its address and TXT records."""
-		# Ask avahi to resolve this particular service
-		path = self._mdns_service.ServiceResolverNew(dbus.Int32(adv.interface()),
-				dbus.Int32(adv.protocol()), adv.name(), adv.stype(), adv.domain(),
-				avahi.PROTO_INET, dbus.UInt32(0))
-		resolver = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, path),
-							avahi.DBUS_INTERFACE_SERVICE_RESOLVER)
-		resolver.connect_to_signal('Found', lambda *args: self._service_resolved_cb_glue(adv, *args))
-		resolver.connect_to_signal('Failure', lambda *args: self._service_resolved_failure_cb(adv, *args))
-		adv.inc_resolv_tries()
-		adv.set_resolver(resolver)
-		return False
-
-	def _service_appeared_cb(self, interface, protocol, full_name, stype, domain, flags):
-		local = flags & avahi.LOOKUP_RESULT_OUR_OWN > 0
-		adv_list = self._find_service_adv(interface=interface, protocol=protocol,
-				name=full_name, stype=stype, domain=domain, local=local)
-		adv = None
-		if not adv_list:
-			adv = ServiceAdv(interface=interface, protocol=protocol, name=full_name,
-					stype=stype, domain=domain, local=local)
-			self._service_advs.append(adv)
-		else:
-			adv = adv_list[0]
-
-		# Decompose service name if we can
-		(actid, buddy_name) = Service.decompose_service_name(full_name)
-
-		# If we care about the service right now, resolve it
-		resolve = False
-		item = self._find_registered_service_type(stype)
-		if actid is not None or item is not None:
-			resolve = True
-		if resolve and adv.state() == _SA_UNRESOLVED:
-			logging.debug("Found '%s' (%d) of type '%s' in domain" \
-					" '%s' on %i.%i; will resolve." % (full_name, flags, stype,
-					domain, interface, protocol))
-			adv.set_state(_SA_RESOLVE_PENDING)
-			gobject.idle_add(self._resolve_service, adv)
-			
-		return False
-
-	def _service_appeared_cb_glue(self, interface, protocol, name, stype, domain, flags):
-		gobject.idle_add(self._service_appeared_cb, interface, protocol, name, stype, domain, flags)
-
-	def _service_disappeared_cb(self, interface, protocol, full_name, stype, domain, flags):
-		local = flags & avahi.LOOKUP_RESULT_OUR_OWN > 0
-		# If it's an unresolved service, remove it from our unresolved list
-		adv_list = self._find_service_adv(interface=interface, protocol=protocol,
-				name=full_name, stype=stype, domain=domain, local=local)
-		if not adv_list:
-			return False
-
-		# Get the service object; if none, we have nothing left to do
-		adv = adv_list[0]
-		service = adv.service()
-		self._service_advs.remove(adv)
-		del adv
-		if not service:
-			return False
-
-		logging.debug("Service %s.%s in domain %s on %i.%i disappeared." % (full_name,
-				stype, domain, interface, protocol))
-
-		self._dbus_helper.ServiceDisappeared(service.object_path())
-		self._handle_remove_activity_service(service)
-
-		# Decompose service name if we can
-		(actid, buddy_name) = Service.decompose_service_name(full_name)
-
-		# Remove the service from the buddy
-		try:
-			buddy = self._buddies[buddy_name]
-		except KeyError:
-			pass
-		else:
-			buddy.remove_service(service)
-			if not buddy.is_valid():
-				self._dbus_helper.BuddyDisappeared(buddy.object_path())
-				del self._buddies[buddy_name]
-		key = (service.get_full_name(), service.get_type())
-		del self._services[key]
-		return False
-
-	def _service_disappeared_cb_glue(self, interface, protocol, name, stype, domain, flags):
-		gobject.idle_add(self._service_disappeared_cb, interface, protocol, name, stype, domain, flags)
-
-	def _new_service_type_cb(self, interface, protocol, stype, domain, flags):
-		# Are we already browsing this domain for this type? 
-		if self._service_browsers.has_key((interface, protocol, stype, domain)):
-			return
-
-		# Start browsing for all services of this type in this domain
-		try:
-			s_browser = self._mdns_service.ServiceBrowserNew(interface,
-					protocol, stype, domain, dbus.UInt32(0))
-			browser_obj = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, s_browser),
-							avahi.DBUS_INTERFACE_SERVICE_BROWSER)
-			browser_obj.connect_to_signal('ItemNew', self._service_appeared_cb_glue)
-			browser_obj.connect_to_signal('ItemRemove', self._service_disappeared_cb_glue)
-
-			self._service_browsers[(interface, protocol, stype, domain)] = browser_obj
-		except dbus.DBusException:
-			logging.debug("Error browsing service type '%s'" % stype)
-		return False
-
-	def _new_service_type_cb_glue(self, interface, protocol, stype, domain, flags):
-		if len(stype) > 0:
-			gobject.idle_add(self._new_service_type_cb, interface, protocol,
-					stype, domain, flags)
-
-	def _new_domain_cb(self, interface, protocol, domain, flags=0):
-		"""Callback from Avahi when a new domain has been found.  Start
-		browsing the new domain."""
-		# Only use .local for now...
-		if domain != "local":
-			return
-
-		# Are we already browsing this domain?
-		if self._service_type_browsers.has_key((interface, protocol, domain)):
-			return
-
-		# Start browsing this domain for the services its members offer
-		try:
-			st_browser = self._mdns_service.ServiceTypeBrowserNew(interface, protocol, domain, dbus.UInt32(0))
-			browser_obj = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, st_browser),
-							avahi.DBUS_INTERFACE_SERVICE_TYPE_BROWSER)
-		except dbus.DBusException, exc:
-			str_exc = str(exc)
-			logging.error("got exception %s while attempting to browse domain %s on %i.%i" % (str_exc, domain, interface, protocol))
-			if str_exc.find("The name org.freedesktop.Avahi was not provided by any .service files") >= 0:
-				raise Exception("Avahi does not appear to be running.  '%s'" % str_exc)
-			else:
-				raise exc
-		logging.debug("Browsing domain '%s' on %i.%i ..." % (domain, interface, protocol))
-		browser_obj.connect_to_signal('ItemNew', self._new_service_type_cb_glue)
-		self._service_type_browsers[(interface, protocol, domain)] = browser_obj
-		return False
-
-	def _new_domain_cb_glue(self, interface, protocol, domain, flags=0):
-		gobject.idle_add(self._new_domain_cb, interface, protocol, domain, flags)
-
-	def join_activity(self, activity, stype, sender):
-		services = activity.get_services_of_type(stype)
-		if not len(services):
-			raise NotFoundError("The service type %s was not present within " \
-					"the activity %s" % (stype, activity.object_path()))
-		act_service = services[0]
-		props = act_service.get_properties()
-		color = activity.get_color()
-		if color:
-			props['color'] = color
-		return self._share_activity(activity.get_id(), stype, properties,
-				act_service.get_address(), act_service.get_port(),
-				act_service.get_domain(), sender)
-
-	def share_activity(self, activity_id, stype, properties=None, address=None,
-			port=-1, domain=u"local", sender=None):
-		"""Convenience function to share an activity with other buddies."""
-		if not util.validate_activity_id(activity_id):
-			raise ValueError("invalid activity id")
-		owner_nick = self._owner.get_name()
-		real_name = Service.compose_service_name(owner_nick, activity_id)
-		if address and not isinstance(address, unicode):
-			raise ValueError("address must be a unicode string.")
-		if address == None and stype.endswith('_udp'):
-			# Use random currently unassigned multicast address
-			address = u"232.%d.%d.%d" % (random.randint(0, 254), random.randint(1, 254),
-					random.randint(1, 254))
-			properties['address'] = address
-			properties['port'] = port
-		if port and port != -1 and (not isinstance(port, int) or port <= 1024 or port >= 65535):
-			raise ValueError("port must be a number between 1024 and 65535")
-		
-		color = self._owner.get_color()
-		if color:
-			properties['color'] = color
-
-		logging.debug('Share activity %s, type %s, address %s, port %d, " \
-				"properties %s' % (activity_id, stype, address, port,
-				properties))
-		return self.register_service(real_name, stype, properties, address,
-				port, domain, sender)
-
-	def register_service(self, name, stype, properties={}, address=None,
-			port=-1, domain=u"local", sender=None):
-		"""Register a new service, advertising it to other Buddies on the network."""
-		# Refuse to register if we can't get the dbus connection this request
-		# came from for some reason
-		if not sender:
-			raise RuntimeError("Service registration request must have a sender.")
-
-		(actid, person_name) = Service.decompose_service_name(name)
-		if self.get_owner() and person_name != self.get_owner().get_name():
-			raise RuntimeError("Tried to register a service that didn't have" \
-					" Owner nick as the service name!")
-		if not domain or not len(domain):
-			domain = u"local"
-		if not port or port == -1:
-			port = random.randint(4000, 65000)
-
-		objid = self._get_next_object_id()
-		service = Service.Service(self._bus_name, objid, name=name,
-				stype=stype, domain=domain, address=address, port=port,
-				properties=properties, source_address=None,
-				local_publisher=sender)
-		self._services[(name, stype)] = service
-		self.register_service_type(stype)
-		service.register(self._system_bus, self._mdns_service)		
-		return service
-
-	def unregister_service(self, service, sender=None):
-		service.unregister(sender)
-
-	def register_service_type(self, stype):
-		"""Requests that the Presence service look for and recognize
-		a certain mDNS service types."""
-		if not isinstance(stype, unicode):
-			raise ValueError("service type must be a unicode string.")
-
-		# If we've already registered it as a service type, ref it and return
-		item = self._find_registered_service_type(stype)
-		if item is not None:
-			item.ref()
-			return
-
-		# Otherwise track this type now
-		obj = RegisteredServiceType(stype)
-		self._registered_service_types.append(obj)
-
-		# Find unresolved services that match the service type
-		# we're now interested in, and resolve them
-		resolv_list = []
-
-		# Find services of this type
-		resolv_list = self._find_service_adv(stype=stype)
-		# Request resolution for them if they aren't in-process already
-		for adv in resolv_list:
-			if adv.state() == _SA_UNRESOLVED:
-				adv.set_state(_SA_RESOLVE_PENDING)
-				gobject.idle_add(self._resolve_service, adv)
-
-	def unregister_service_type(self, stype):
-		"""Stop tracking a certain mDNS service."""
-		if not isinstance(stype, unicode):
-			raise ValueError("service type must be a unicode string.")
-
-		# if it was found, unref it and possibly remove it
-		item = self._find_registered_service_type(stype)
-		if not item:
-			return
-		if item.unref() <= 0:
-			self._registered_service_types.remove(item)
-			del item
+    def __init__(self):
+        # interface -> IP address: interfaces we've gotten events on so far
+        self._started = False
+        self._local_addrs = {}
+
+        self._next_object_id = 0
+
+        self._buddies = {}         # nick -> Buddy
+        self._services = {}        # (name, type) -> Service
+        self._activities = {}    # activity id -> Activity
+
+        # Keep track of stuff we're already browsing
+        self._service_type_browsers = {}
+        self._service_browsers = {}
+
+        # Resolved service list
+        self._service_advs = []
+
+        # Service types we care about resolving
+        self._registered_service_types = []
+
+        # Set up the dbus service we provide
+        self._session_bus = dbus.SessionBus()
+        self._bus_name = dbus.service.BusName(_PRESENCE_SERVICE, bus=self._session_bus)        
+        self._dbus_helper = PresenceServiceDBusHelper(self, self._bus_name)
+
+        self._icon_cache = BuddyIconCache.BuddyIconCache()
+
+        # Our owner object
+        if profile.get_nick_name():
+            objid = self._get_next_object_id()
+            self._owner = Buddy.Owner(self, self._bus_name,
+                                      objid, self._icon_cache)
+            self._buddies[self._owner.get_name()] = self._owner
+        else:
+            self._owner = None
+
+    def start(self):
+        if self._started:
+            return
+        self._started = True
+
+        # Connect to Avahi for mDNS stuff
+        self._system_bus = dbus.SystemBus()
+        self._mdns_service = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME,
+                avahi.DBUS_PATH_SERVER), avahi.DBUS_INTERFACE_SERVER)
+
+        # Always browse .local
+        self._new_domain_cb(avahi.IF_UNSPEC, avahi.PROTO_INET, "local")
+
+        # Connect to Avahi and start looking for stuff
+        domain_browser = self._mdns_service.DomainBrowserNew(avahi.IF_UNSPEC, avahi.PROTO_INET,
+                        "", avahi.DOMAIN_BROWSER_BROWSE, dbus.UInt32(0))
+        db = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, domain_browser), avahi.DBUS_INTERFACE_DOMAIN_BROWSER)
+        db.connect_to_signal('ItemNew', self._new_domain_cb_glue)
+
+    def _get_next_object_id(self):
+        """Increment and return the object ID counter."""
+        self._next_object_id = self._next_object_id + 1
+        return self._next_object_id
+
+    def get_services(self):
+        return self._services.values()
+
+    def get_services_of_type(self, stype):
+        ret = []
+        for serv in self._services.values():
+            if serv.get_type() == stype:
+                ret.append(serv)
+        return ret
+
+    def get_activities(self):
+        # Only return valid activities
+        ret = []
+        for act in self._activities.values():
+            if act.is_valid():
+                ret.append(act)
+        return ret
+
+    def get_activity(self, actid):
+        if self._activities.has_key(actid):
+            act = self._activities[actid]
+            if act.is_valid():
+                return act
+        return None
+
+    def get_buddies(self):
+        buddies = []
+        for buddy in self._buddies.values():
+            if buddy.is_valid():
+                buddies.append(buddy)
+        return buddies
+
+    def get_buddy_by_name(self, name):
+        if self._buddies.has_key(name):
+            if self._buddies[name].is_valid():
+                return self._buddies[name]
+        return None
+
+    def get_buddy_by_address(self, address):
+        for buddy in self._buddies.values():
+            if buddy.get_address() == address and buddy.is_valid():
+                return buddy
+        return None
+
+    def get_owner(self):
+        return self._owner
+
+    def _find_service_adv(self, interface=None, protocol=None, name=None,
+            stype=None, domain=None, local=None):
+        """Search a list of service advertisements for ones matching
+        certain criteria."""
+        adv_list = []
+        for adv in self._service_advs:
+            if interface and adv.interface() != interface:
+                continue
+            if protocol and adv.protocol() != protocol:
+                continue
+            if name and adv.name() != name:
+                continue
+            if stype and adv.stype() != stype:
+                continue
+            if domain and adv.domain() != domain:
+                continue
+            if local is not None and adv.is_local() != local:
+                continue
+            adv_list.append(adv)
+        return adv_list
+
+    def _find_registered_service_type(self, stype):
+        for item in self._registered_service_types:
+            if item.get_type() == stype:
+                return item
+        return None
+
+    def _handle_new_service_for_buddy(self, service, local):
+        """Deal with a new discovered service object."""
+        # Once a service is resolved, we match it up to an existing buddy,
+        # or create a new Buddy if this is the first service known about the buddy
+        buddy_was_valid = False
+        name = service.get_name()
+        buddy = None
+        try:
+            buddy = self._buddies[name]
+            buddy_was_valid = buddy.is_valid()
+            service_added = buddy.add_service(service)
+            if service_added:
+                self._dbus_helper.ServiceAppeared(service.object_path())
+        except KeyError:
+            source_addr = service.get_source_address()
+            objid = self._get_next_object_id()
+            buddy = Buddy.Buddy(self._bus_name, objid, service, self._icon_cache)
+            self._buddies[name] = buddy
+            self._dbus_helper.ServiceAppeared(service.object_path())
+        if not buddy_was_valid and buddy.is_valid():
+            self._dbus_helper.BuddyAppeared(buddy.object_path())
+        return buddy
+
+    def _handle_new_activity_service(self, service):
+        # If the serivce is an activity service, merge it into our activities list
+        actid = service.get_activity_id()
+        if not actid:
+            return
+        activity = None
+        was_valid = False
+        if not self._activities.has_key(actid):
+            objid = self._get_next_object_id()
+            activity = Activity.Activity(self._bus_name, objid, service)
+            self._activities[actid] = activity
+        else:
+            activity = self._activities[actid]
+            was_valid = activity.is_valid()
+
+        if activity:
+            activity.add_service(service)
+
+            # Add the activity to its buddy
+            # FIXME: use something other than name to attribute to buddy
+            try:
+                buddy = self._buddies[service.get_name()]
+                buddy.add_activity(activity)
+            except KeyError:
+                pass        
+
+        if not was_valid and activity.is_valid():
+            self._dbus_helper.ActivityAppeared(activity.object_path())
+
+    def _handle_remove_activity_service(self, service):
+        actid = service.get_activity_id()
+        if not actid:
+            return
+        if not self._activities.has_key(actid):
+            return
+
+        activity = self._activities[actid]
+
+        activity.remove_service(service)
+        if len(activity.get_services()) == 0:
+            # Remove the activity from its buddy
+            # FIXME: use something other than name to attribute to buddy
+            try:
+                buddy = self._buddies[service.get_name()]
+                buddy.remove_activity(activity)
+            except KeyError:
+                pass        
+
+            # Kill the activity
+            self._dbus_helper.ActivityDisappeared(activity.object_path())
+            del self._activities[actid]
+
+    def _service_resolved_cb(self, adv, interface, protocol, full_name,
+            stype, domain, host, aprotocol, address, port, txt, flags,
+            updated):
+        """When the service discovery finally gets here, we've got enough
+        information about the service to assign it to a buddy."""
+        if updated == False:
+            logging.debug("Resolved service '%s' type '%s' domain '%s' to " \
+                    " %s:%s" % (full_name, stype, domain, address, port))
+
+        if not adv in self._service_advs:
+            return False
+        if adv.state() != _SA_RESOLVED:
+            return False
+
+        # See if we know about this service already
+        service = None
+        key = (full_name, stype)
+        props = _txt_to_dict(txt)
+        if not self._services.has_key(key):
+            objid = self._get_next_object_id()
+            service = Service.Service(self._bus_name, objid, name=full_name,
+                    stype=stype, domain=domain, address=address, port=port,
+                    properties=props, source_address=address)
+            self._services[key] = service
+        else:
+            # Already tracking this service; either:
+            # a) we were the one that shared it in the first place,
+            #     and therefore the source address would not have
+            #     been set yet
+            # b) the service has been updated
+            service = self._services[key]
+            if not service.get_source_address():
+                service.set_source_address(address)
+            if not service.get_address():
+                service.set_address(address)
+
+        adv.set_service(service)
+
+        if service and updated:
+            service.set_properties(props, from_network=True)
+            return False
+
+        # Merge the service into our buddy and activity lists, if needed
+        buddy = self._handle_new_service_for_buddy(service, adv.is_local())
+        if buddy and service.get_activity_id():
+            self._handle_new_activity_service(service)
+
+        return False
+
+    def _service_resolved_cb_glue(self, adv, interface, protocol, name,
+            stype, domain, host, aprotocol, address, port, txt, flags):
+        # Avahi doesn't flag updates to existing services, so we have
+        # to determine that here
+        updated = False
+        if adv.state() == _SA_RESOLVED:
+            updated = True
+
+        adv.set_state(_SA_RESOLVED)
+        gobject.idle_add(self._service_resolved_cb, adv, interface,
+                protocol, name, stype, domain, host, aprotocol, address,
+                port, txt, flags, updated)
+
+    def _service_resolved_failure_cb(self, adv, err):
+        retried = False
+        adv.set_resolver(None)
+        if adv.stype() == Buddy.PRESENCE_SERVICE_TYPE:
+            # Retry the presence service type a few times
+            if adv.resolv_tries() < 4:
+                adv.set_state(_SA_RESOLVE_PENDING)
+                gobject.timeout_add(250, self._resolve_service, adv)
+                retried = True
+                logging.error("Retrying resolution of service %s.%s: %s" % (adv.name(),
+                    adv.stype(), err))
+
+        if not retried:
+            logging.error("Error resolving service %s.%s: %s" % (adv.name(),
+                    adv.stype(), err))
+            adv.set_state(_SA_UNRESOLVED)
+
+    def _resolve_service(self, adv):
+        """Resolve and lookup a ZeroConf service to obtain its address and TXT records."""
+        # Ask avahi to resolve this particular service
+        path = self._mdns_service.ServiceResolverNew(dbus.Int32(adv.interface()),
+                dbus.Int32(adv.protocol()), adv.name(), adv.stype(), adv.domain(),
+                avahi.PROTO_INET, dbus.UInt32(0))
+        resolver = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, path),
+                            avahi.DBUS_INTERFACE_SERVICE_RESOLVER)
+        resolver.connect_to_signal('Found', lambda *args: self._service_resolved_cb_glue(adv, *args))
+        resolver.connect_to_signal('Failure', lambda *args: self._service_resolved_failure_cb(adv, *args))
+        adv.inc_resolv_tries()
+        adv.set_resolver(resolver)
+        return False
+
+    def _service_appeared_cb(self, interface, protocol, full_name, stype, domain, flags):
+        local = flags & avahi.LOOKUP_RESULT_OUR_OWN > 0
+        adv_list = self._find_service_adv(interface=interface, protocol=protocol,
+                name=full_name, stype=stype, domain=domain, local=local)
+        adv = None
+        if not adv_list:
+            adv = ServiceAdv(interface=interface, protocol=protocol, name=full_name,
+                    stype=stype, domain=domain, local=local)
+            self._service_advs.append(adv)
+        else:
+            adv = adv_list[0]
+
+        # Decompose service name if we can
+        (actid, buddy_name) = Service.decompose_service_name(full_name)
+
+        # If we care about the service right now, resolve it
+        resolve = False
+        item = self._find_registered_service_type(stype)
+        if actid is not None or item is not None:
+            resolve = True
+        if resolve and adv.state() == _SA_UNRESOLVED:
+            logging.debug("Found '%s' (%d) of type '%s' in domain" \
+                    " '%s' on %i.%i; will resolve." % (full_name, flags, stype,
+                    domain, interface, protocol))
+            adv.set_state(_SA_RESOLVE_PENDING)
+            gobject.idle_add(self._resolve_service, adv)
+            
+        return False
+
+    def _service_appeared_cb_glue(self, interface, protocol, name, stype, domain, flags):
+        gobject.idle_add(self._service_appeared_cb, interface, protocol, name, stype, domain, flags)
+
+    def _service_disappeared_cb(self, interface, protocol, full_name, stype, domain, flags):
+        local = flags & avahi.LOOKUP_RESULT_OUR_OWN > 0
+        # If it's an unresolved service, remove it from our unresolved list
+        adv_list = self._find_service_adv(interface=interface, protocol=protocol,
+                name=full_name, stype=stype, domain=domain, local=local)
+        if not adv_list:
+            return False
+
+        # Get the service object; if none, we have nothing left to do
+        adv = adv_list[0]
+        service = adv.service()
+        self._service_advs.remove(adv)
+        del adv
+        if not service:
+            return False
+
+        logging.debug("Service %s.%s in domain %s on %i.%i disappeared." % (full_name,
+                stype, domain, interface, protocol))
+
+        self._dbus_helper.ServiceDisappeared(service.object_path())
+        self._handle_remove_activity_service(service)
+
+        # Decompose service name if we can
+        (actid, buddy_name) = Service.decompose_service_name(full_name)
+
+        # Remove the service from the buddy
+        try:
+            buddy = self._buddies[buddy_name]
+        except KeyError:
+            pass
+        else:
+            buddy.remove_service(service)
+            if not buddy.is_valid():
+                self._dbus_helper.BuddyDisappeared(buddy.object_path())
+                del self._buddies[buddy_name]
+        key = (service.get_full_name(), service.get_type())
+        del self._services[key]
+        return False
+
+    def _service_disappeared_cb_glue(self, interface, protocol, name, stype, domain, flags):
+        gobject.idle_add(self._service_disappeared_cb, interface, protocol, name, stype, domain, flags)
+
+    def _new_service_type_cb(self, interface, protocol, stype, domain, flags):
+        # Are we already browsing this domain for this type? 
+        if self._service_browsers.has_key((interface, protocol, stype, domain)):
+            return
+
+        # Start browsing for all services of this type in this domain
+        try:
+            s_browser = self._mdns_service.ServiceBrowserNew(interface,
+                    protocol, stype, domain, dbus.UInt32(0))
+            browser_obj = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, s_browser),
+                            avahi.DBUS_INTERFACE_SERVICE_BROWSER)
+            browser_obj.connect_to_signal('ItemNew', self._service_appeared_cb_glue)
+            browser_obj.connect_to_signal('ItemRemove', self._service_disappeared_cb_glue)
+
+            self._service_browsers[(interface, protocol, stype, domain)] = browser_obj
+        except dbus.DBusException:
+            logging.debug("Error browsing service type '%s'" % stype)
+        return False
+
+    def _new_service_type_cb_glue(self, interface, protocol, stype, domain, flags):
+        if len(stype) > 0:
+            gobject.idle_add(self._new_service_type_cb, interface, protocol,
+                    stype, domain, flags)
+
+    def _new_domain_cb(self, interface, protocol, domain, flags=0):
+        """Callback from Avahi when a new domain has been found.  Start
+        browsing the new domain."""
+        # Only use .local for now...
+        if domain != "local":
+            return
+
+        # Are we already browsing this domain?
+        if self._service_type_browsers.has_key((interface, protocol, domain)):
+            return
+
+        # Start browsing this domain for the services its members offer
+        try:
+            st_browser = self._mdns_service.ServiceTypeBrowserNew(interface, protocol, domain, dbus.UInt32(0))
+            browser_obj = dbus.Interface(self._system_bus.get_object(avahi.DBUS_NAME, st_browser),
+                            avahi.DBUS_INTERFACE_SERVICE_TYPE_BROWSER)
+        except dbus.DBusException, exc:
+            str_exc = str(exc)
+            logging.error("got exception %s while attempting to browse domain %s on %i.%i" % (str_exc, domain, interface, protocol))
+            if str_exc.find("The name org.freedesktop.Avahi was not provided by any .service files") >= 0:
+                raise Exception("Avahi does not appear to be running.  '%s'" % str_exc)
+            else:
+                raise exc
+        logging.debug("Browsing domain '%s' on %i.%i ..." % (domain, interface, protocol))
+        browser_obj.connect_to_signal('ItemNew', self._new_service_type_cb_glue)
+        self._service_type_browsers[(interface, protocol, domain)] = browser_obj
+        return False
+
+    def _new_domain_cb_glue(self, interface, protocol, domain, flags=0):
+        gobject.idle_add(self._new_domain_cb, interface, protocol, domain, flags)
+
+    def join_activity(self, activity, stype, sender):
+        services = activity.get_services_of_type(stype)
+        if not len(services):
+            raise NotFoundError("The service type %s was not present within " \
+                    "the activity %s" % (stype, activity.object_path()))
+        act_service = services[0]
+        props = act_service.get_properties()
+        color = activity.get_color()
+        if color:
+            props['color'] = color
+        return self._share_activity(activity.get_id(), stype, properties,
+                act_service.get_address(), act_service.get_port(),
+                act_service.get_domain(), sender)
+
+    def share_activity(self, activity_id, stype, properties=None, address=None,
+            port=-1, domain=u"local", sender=None):
+        """Convenience function to share an activity with other buddies."""
+        if not util.validate_activity_id(activity_id):
+            raise ValueError("invalid activity id")
+        owner_nick = self._owner.get_name()
+        real_name = Service.compose_service_name(owner_nick, activity_id)
+        if address and not isinstance(address, unicode):
+            raise ValueError("address must be a unicode string.")
+        if address == None and stype.endswith('_udp'):
+            # Use random currently unassigned multicast address
+            address = u"232.%d.%d.%d" % (random.randint(0, 254), random.randint(1, 254),
+                    random.randint(1, 254))
+            properties['address'] = address
+            properties['port'] = port
+        if port and port != -1 and (not isinstance(port, int) or port <= 1024 or port >= 65535):
+            raise ValueError("port must be a number between 1024 and 65535")
+        
+        color = self._owner.get_color()
+        if color:
+            properties['color'] = color
+
+        logging.debug('Share activity %s, type %s, address %s, port %d, " \
+                "properties %s' % (activity_id, stype, address, port,
+                properties))
+        return self.register_service(real_name, stype, properties, address,
+                port, domain, sender)
+
+    def register_service(self, name, stype, properties={}, address=None,
+            port=-1, domain=u"local", sender=None):
+        """Register a new service, advertising it to other Buddies on the network."""
+        # Refuse to register if we can't get the dbus connection this request
+        # came from for some reason
+        if not sender:
+            raise RuntimeError("Service registration request must have a sender.")
+
+        (actid, person_name) = Service.decompose_service_name(name)
+        if self.get_owner() and person_name != self.get_owner().get_name():
+            raise RuntimeError("Tried to register a service that didn't have" \
+                    " Owner nick as the service name!")
+        if not domain or not len(domain):
+            domain = u"local"
+        if not port or port == -1:
+            port = random.randint(4000, 65000)
+
+        objid = self._get_next_object_id()
+        service = Service.Service(self._bus_name, objid, name=name,
+                stype=stype, domain=domain, address=address, port=port,
+                properties=properties, source_address=None,
+                local_publisher=sender)
+        self._services[(name, stype)] = service
+        self.register_service_type(stype)
+        service.register(self._system_bus, self._mdns_service)        
+        return service
+
+    def unregister_service(self, service, sender=None):
+        service.unregister(sender)
+
+    def register_service_type(self, stype):
+        """Requests that the Presence service look for and recognize
+        a certain mDNS service types."""
+        if not isinstance(stype, unicode):
+            raise ValueError("service type must be a unicode string.")
+
+        # If we've already registered it as a service type, ref it and return
+        item = self._find_registered_service_type(stype)
+        if item is not None:
+            item.ref()
+            return
+
+        # Otherwise track this type now
+        obj = RegisteredServiceType(stype)
+        self._registered_service_types.append(obj)
+
+        # Find unresolved services that match the service type
+        # we're now interested in, and resolve them
+        resolv_list = []
+
+        # Find services of this type
+        resolv_list = self._find_service_adv(stype=stype)
+        # Request resolution for them if they aren't in-process already
+        for adv in resolv_list:
+            if adv.state() == _SA_UNRESOLVED:
+                adv.set_state(_SA_RESOLVE_PENDING)
+                gobject.idle_add(self._resolve_service, adv)
+
+    def unregister_service_type(self, stype):
+        """Stop tracking a certain mDNS service."""
+        if not isinstance(stype, unicode):
+            raise ValueError("service type must be a unicode string.")
+
+        # if it was found, unref it and possibly remove it
+        item = self._find_registered_service_type(stype)
+        if not item:
+            return
+        if item.unref() <= 0:
+            self._registered_service_types.remove(item)
+            del item
 
 
 def main():
-	from sugar import TracebackUtils
-	loop = gobject.MainLoop()
-	ps = PresenceService()
-	tbh = TracebackUtils.TracebackHelper()
-	try:
-		loop.run()
-	except KeyboardInterrupt:
-		print 'Ctrl+C pressed, exiting...'
+    from sugar import TracebackUtils
+    loop = gobject.MainLoop()
+    ps = PresenceService()
+    tbh = TracebackUtils.TracebackHelper()
+    try:
+        loop.run()
+    except KeyboardInterrupt:
+        print 'Ctrl+C pressed, exiting...'
 
-	del tbh
+    del tbh
 
 
 if __name__ == "__main__":
-	main()
+    main()
diff --git a/services/presence/Service.py b/services/presence/Service.py
index bb41f88..5072ed5 100644
--- a/services/presence/Service.py
+++ b/services/presence/Service.py
@@ -24,61 +24,61 @@ import logging
 import gobject
 
 def compose_service_name(name, activity_id):
-	if isinstance(name, str):
-		name = unicode(name)
-	if not name:
-		raise ValueError("name must be a valid string.")
-	if not activity_id:
-		return name
-	if not isinstance(name, unicode):
-		raise ValueError("name must be in unicode.")
-	composed = "%s [%s]" % (name, activity_id)
-	return composed
+    if isinstance(name, str):
+        name = unicode(name)
+    if not name:
+        raise ValueError("name must be a valid string.")
+    if not activity_id:
+        return name
+    if not isinstance(name, unicode):
+        raise ValueError("name must be in unicode.")
+    composed = "%s [%s]" % (name, activity_id)
+    return composed
 
 def decompose_service_name(name):
-	"""Break a service name into the name and activity ID, if we can."""
-	if not isinstance(name, unicode):
-		raise ValueError("name must be a valid unicode string.")
-	name_len = len(name)
-	if name_len < util.ACTIVITY_ID_LEN + 5:
-		return (None, name)
-	# check for activity id end marker
-	if name[name_len - 1] != "]":
-		return (None, name)
-	start = name_len - 1 - util.ACTIVITY_ID_LEN
-	end = name_len - 1
-	# check for activity id start marker
-	if name[start - 1] != "[" or name[start - 2] != " ":
-		return (None, name)
-	activity_id = name[start:end]
-	if not util.validate_activity_id(activity_id):
-		return (None, name)
-	return (activity_id, name[:start - 2])
+    """Break a service name into the name and activity ID, if we can."""
+    if not isinstance(name, unicode):
+        raise ValueError("name must be a valid unicode string.")
+    name_len = len(name)
+    if name_len < util.ACTIVITY_ID_LEN + 5:
+        return (None, name)
+    # check for activity id end marker
+    if name[name_len - 1] != "]":
+        return (None, name)
+    start = name_len - 1 - util.ACTIVITY_ID_LEN
+    end = name_len - 1
+    # check for activity id start marker
+    if name[start - 1] != "[" or name[start - 2] != " ":
+        return (None, name)
+    activity_id = name[start:end]
+    if not util.validate_activity_id(activity_id):
+        return (None, name)
+    return (activity_id, name[:start - 2])
 
 def _one_dict_differs(dict1, dict2):
-	diff_keys = []
-	for key, value in dict1.items():
-		if not dict2.has_key(key) or dict2[key] != value:
-			diff_keys.append(key)
-	return diff_keys
+    diff_keys = []
+    for key, value in dict1.items():
+        if not dict2.has_key(key) or dict2[key] != value:
+            diff_keys.append(key)
+    return diff_keys
 
 def _dicts_differ(dict1, dict2):
-	diff_keys = []
-	diff1 = _one_dict_differs(dict1, dict2)
-	diff2 = _one_dict_differs(dict2, dict1)
-	for key in diff2:
-		if key not in diff1:
-			diff_keys.append(key)
-	diff_keys += diff1
-	return diff_keys
+    diff_keys = []
+    diff1 = _one_dict_differs(dict1, dict2)
+    diff2 = _one_dict_differs(dict2, dict1)
+    for key in diff2:
+        if key not in diff1:
+            diff_keys.append(key)
+    diff_keys += diff1
+    return diff_keys
 
 def _convert_properties_to_dbus_byte_array(props):
-	# Ensure properties are converted to ByteArray types
-	# because python sometimes can't figure that out
-	info = dbus.Array([], signature="aay")
-	for k, v in props.items():
-		info.append(dbus.types.ByteArray("%s=%s" % (k, v)))
-	return info
+    # Ensure properties are converted to ByteArray types
+    # because python sometimes can't figure that out
+    info = dbus.Array([], signature="aay")
+    for k, v in props.items():
+        info.append(dbus.types.ByteArray("%s=%s" % (k, v)))
+    return info
 
 
 _ACTIVITY_ID_TAG = "ActivityID"
@@ -86,360 +86,360 @@ SERVICE_DBUS_INTERFACE = "org.laptop.Presence.Service"
 SERVICE_DBUS_OBJECT_PATH = "/org/laptop/Presence/Services/"
 
 class ServiceDBusHelper(dbus.service.Object):
-	"""Handle dbus requests and signals for Service objects"""
-	def __init__(self, parent, bus_name, object_path):
-		self._parent = parent
-		self._bus_name = bus_name
-		self._object_path = object_path
-		dbus.service.Object.__init__(self, bus_name, self._object_path)
-
-	@dbus.service.signal(SERVICE_DBUS_INTERFACE,
-						signature="as")
-	def PublishedValueChanged(self, keylist):
-		pass
-
-	@dbus.service.method(SERVICE_DBUS_INTERFACE,
-						in_signature="", out_signature="a{sv}")
-	def getProperties(self):
-		"""Return service properties."""
-		pary = {}
-		pary['name'] = self._parent.get_name()
-		pary['type'] = self._parent.get_type()
-		pary['domain'] = self._parent.get_domain()
-		actid = self._parent.get_activity_id()
-		if actid:
-			pary['activityId'] = actid
-		port = self._parent.get_port()
-		if port:
-			pary['port'] = self._parent.get_port()
-		addr = self._parent.get_address()
-		if addr:
-			pary['address'] = addr
-		source_addr = self._parent.get_source_address()
-		if source_addr:
-			pary['sourceAddress'] = source_addr
-		return pary
-
-	@dbus.service.method(SERVICE_DBUS_INTERFACE,
-						in_signature="s")
-	def getPublishedValue(self, key):
-		"""Return the value belonging to the requested key from the
-		service's TXT records."""
-		val = self._parent.get_one_property(key)
-		if not val:
-			raise KeyError("Value was not found.")
-		return val
-
-	@dbus.service.method(SERVICE_DBUS_INTERFACE,
-						in_signature="", out_signature="a{sv}")
-	def getPublishedValues(self):
-		pary = {}
-		props = self._parent.get_properties()
-		for key, value in props.items():
-			pary[key] = str(value)
-		return dbus.Dictionary(pary)
-
-	@dbus.service.method(SERVICE_DBUS_INTERFACE,
-						sender_keyword="sender")
-	def setPublishedValue(self, key, value, sender):
-		self._parent.set_property(key, value, sender)
-
-	@dbus.service.method(SERVICE_DBUS_INTERFACE,
-						in_signature="a{sv}", sender_keyword="sender")
-	def setPublishedValues(self, values, sender):
-		if not self._parent.is_local():
-			raise ValueError("Service was not not registered by requesting process!")		
-		self._parent.set_properties(values, sender)
+    """Handle dbus requests and signals for Service objects"""
+    def __init__(self, parent, bus_name, object_path):
+        self._parent = parent
+        self._bus_name = bus_name
+        self._object_path = object_path
+        dbus.service.Object.__init__(self, bus_name, self._object_path)
+
+    @dbus.service.signal(SERVICE_DBUS_INTERFACE,
+                        signature="as")
+    def PublishedValueChanged(self, keylist):
+        pass
+
+    @dbus.service.method(SERVICE_DBUS_INTERFACE,
+                        in_signature="", out_signature="a{sv}")
+    def getProperties(self):
+        """Return service properties."""
+        pary = {}
+        pary['name'] = self._parent.get_name()
+        pary['type'] = self._parent.get_type()
+        pary['domain'] = self._parent.get_domain()
+        actid = self._parent.get_activity_id()
+        if actid:
+            pary['activityId'] = actid
+        port = self._parent.get_port()
+        if port:
+            pary['port'] = self._parent.get_port()
+        addr = self._parent.get_address()
+        if addr:
+            pary['address'] = addr
+        source_addr = self._parent.get_source_address()
+        if source_addr:
+            pary['sourceAddress'] = source_addr
+        return pary
+
+    @dbus.service.method(SERVICE_DBUS_INTERFACE,
+                        in_signature="s")
+    def getPublishedValue(self, key):
+        """Return the value belonging to the requested key from the
+        service's TXT records."""
+        val = self._parent.get_one_property(key)
+        if not val:
+            raise KeyError("Value was not found.")
+        return val
+
+    @dbus.service.method(SERVICE_DBUS_INTERFACE,
+                        in_signature="", out_signature="a{sv}")
+    def getPublishedValues(self):
+        pary = {}
+        props = self._parent.get_properties()
+        for key, value in props.items():
+            pary[key] = str(value)
+        return dbus.Dictionary(pary)
+
+    @dbus.service.method(SERVICE_DBUS_INTERFACE,
+                        sender_keyword="sender")
+    def setPublishedValue(self, key, value, sender):
+        self._parent.set_property(key, value, sender)
+
+    @dbus.service.method(SERVICE_DBUS_INTERFACE,
+                        in_signature="a{sv}", sender_keyword="sender")
+    def setPublishedValues(self, values, sender):
+        if not self._parent.is_local():
+            raise ValueError("Service was not not registered by requesting process!")        
+        self._parent.set_properties(values, sender)
 
 
 class Service(gobject.GObject):
-	"""Encapsulates information about a specific ZeroConf/mDNS
-	service as advertised on the network."""
-
-	__gsignals__ = {
-		'property-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
-						 ([gobject.TYPE_PYOBJECT]))
-	}
-
-	def __init__(self, bus_name, object_id, name, stype, domain=u"local",
-				address=None, port=-1, properties=None, source_address=None,
-				local_publisher=None):
-		gobject.GObject.__init__(self)
-		if not bus_name:
-			raise ValueError("DBus bus name must be valid")
-		if not object_id or not isinstance(object_id, int):
-			raise ValueError("object id must be a valid number")
-
-		# Validate immutable options
-		if name and not isinstance(name, unicode):
-			raise ValueError("name must be unicode.")
-		if not name or not len(name):
-			raise ValueError("must specify a valid service name.")
-
-		if stype and not isinstance(stype, unicode):
-			raise ValueError("service type must be in unicode.")
-		if not stype or not len(stype):
-			raise ValueError("must specify a valid service type.")
-		if not stype.endswith("._tcp") and not stype.endswith("._udp"):
-			raise ValueError("must specify a TCP or UDP service type.")
-
-		if not isinstance(domain, unicode):
-			raise ValueError("domain must be in unicode.")
-		if domain and domain != "local":
-			raise ValueError("must use the 'local' domain (for now).")
-
-		# ID of the D-Bus connection that published this service, if any.
-		# We only let the local publisher modify the service.
-		self._local_publisher = local_publisher
-
-		self._avahi_entry_group = None
-
-		(actid, real_name) = decompose_service_name(name)
-		self._name = real_name
-		self._full_name = name
-		self._stype = stype
-		self._domain = domain
-		self._port = -1
-		self.set_port(port)
-		self._properties = {}
-		self._dbus_helper = None
-		self._internal_set_properties(properties)
-
-		# Source address is the unicast source IP
-		self._source_address = None
-		if source_address is not None:
-			self.set_source_address(source_address)
-
-		# Address is the published address, could be multicast or unicast
-		self._address = None
-		if self._properties.has_key('address'):
-			self.set_address(self._properties['address'])
-		elif address is not None:
-			self.set_address(address)
-			self._properties['address'] = address
-
-		# Ensure that an ActivityID tag, if given, matches
-		# what we expect from the service type
-		if self._properties.has_key(_ACTIVITY_ID_TAG):
-			prop_actid = self._properties[_ACTIVITY_ID_TAG]
-			if (prop_actid and not actid) or (prop_actid != actid):
-				raise ValueError("ActivityID property specified, but the " \
-						"service names's activity ID didn't match it: %s," \
-						" %s" % (prop_actid, actid))
-		self._activity_id = actid
-		if actid and not self._properties.has_key(_ACTIVITY_ID_TAG):
-			self._properties[_ACTIVITY_ID_TAG] = actid
-
-		self._owner = None
-
-		# register ourselves with dbus
-		self._object_id = object_id
-		self._object_path = SERVICE_DBUS_OBJECT_PATH + str(self._object_id)
-		self._dbus_helper = ServiceDBusHelper(self, bus_name, self._object_path)
-
-	def object_path(self):
-		return dbus.ObjectPath(self._object_path)
-
-	def get_owner(self):
-		return self._owner
-
-	def set_owner(self, owner):
-		if self._owner is not None:
-			raise RuntimeError("Can only set a service's owner once")
-		self._owner = owner
-
-	def is_local(self):
-		if self._local_publisher is not None:
-			return True
-		return False
-
-	def get_name(self):
-		"""Return the service's name, usually that of the
-		buddy who provides it."""
-		return self._name
-
-	def get_full_name(self):
-		return self._full_name
-
-	def get_one_property(self, key):
-		"""Return one property of the service, or None
-		if the property was not found.  Cannot distinguish
-		between lack of a property, and a property value that
-		actually is None."""
-		if key in self._properties.keys():
-			return self._properties[key]
-		return None
-
-	def get_properties(self):
-		"""Return a python dictionary of all the service's
-		properties."""
-		return self._properties
-
-	def __emit_properties_changed_signal(self, keys):
-		if self._dbus_helper:
-			self._dbus_helper.PublishedValueChanged(keys)
-		self.emit('property-changed', keys)
-
-	def set_property(self, key, value, sender=None):
-		"""Set one service property"""
-		if not self._local_publisher:
-			raise ValueError("Service was not not registered by requesting process!")		
-		if sender is not None and self._local_publisher != sender:
-			raise ValueError("Service was not not registered by requesting process!")
-
-		if not isinstance(key, unicode):
-			raise ValueError("Key must be a unicode string.")
-		if not isinstance(value, unicode) and not isinstance(value, bool):
-			raise ValueError("Key must be a unicode string or a boolean.")
-
-		# Ignore setting the key to it's current value
-		if self._properties.has_key(key):
-			if self._properties[key] == value:
-				return
-
-		# Blank value means remove key
-		remove = False
-		if isinstance(value, unicode) and len(value) == 0:
-			remove = True
-		if isinstance(value, bool) and value == False:
-			remove = True
-
-		if remove:
-			# If the key wasn't present, return without error
-			if self._properties.has_key(key):
-				del self._properties[key]
-		else:
-			# Otherwise set it
-			if isinstance(value, bool):
-				value = ""
-			self._properties[key] = value
-
-		# if the service is locally published already, update the TXT records
-		if self._local_publisher and self._avahi_entry_group:
-			self.__internal_update_avahi_properties()
-
-		self.__emit_properties_changed_signal([key])
-
-	def set_properties(self, properties, sender=None, from_network=False):
-		"""Set all service properties in one call"""
-		if sender is not None and self._local_publisher != sender:
-			raise ValueError("Service was not not registered by requesting process!")
-
-		self._internal_set_properties(properties, from_network)
-
-	def _internal_set_properties(self, properties, from_network=False):
-		"""Set the service's properties from either an Avahi
-		TXT record (a list of lists of integers), or a
-		python dictionary."""
-		if not isinstance (properties, dict):
-			raise ValueError("Properties must be a dictionary.")
-
-		# Make sure the properties are actually different
-		diff_keys = _dicts_differ(self._properties, properties)
-		if len(diff_keys) == 0:
-			return
-
-		self._properties = {}
-		# Set key/value pairs on internal property list
-		for key, value in properties.items():
-			if len(key) == 0:
-				continue
-			tmp_key = key
-			tmp_val = value
-			if not isinstance(tmp_key, unicode):
-				tmp_key = unicode(tmp_key)
-			if not isinstance(tmp_val, unicode):
-				tmp_val = unicode(tmp_val)
-			self._properties[tmp_key] = tmp_val
-
-		# if the service is locally published already, update the TXT records
-		if self._local_publisher and self._avahi_entry_group and not from_network:
-			self.__internal_update_avahi_properties()
-
-		self.__emit_properties_changed_signal(diff_keys)
-
-	def __internal_update_avahi_properties(self):
-		info = _convert_properties_to_dbus_byte_array(self._properties)
-		self._avahi_entry_group.UpdateServiceTxt(avahi.IF_UNSPEC,
-				avahi.PROTO_UNSPEC, 0,
-				dbus.String(self._full_name), dbus.String(self._stype),
-				dbus.String(self._domain), info)
-
-	def get_type(self):
-		"""Return the service's service type."""
-		return self._stype
-
-	def get_activity_id(self):
-		"""Return the activity ID this service is associated with, if any."""
-		return self._activity_id
-
-	def get_port(self):
-		return self._port
-
-	def set_port(self, port):
-		if not isinstance(port, int) or (port <= 1024 and port > 65536):
-			raise ValueError("must specify a valid port number between 1024 and 65536.")
-		self._port = port
-
-	def get_source_address(self):
-		return self._source_address
-
-	def set_source_address(self, address):
-		if not address or not isinstance(address, unicode):
-			raise ValueError("address must be unicode")
-		self._source_address = address
-
-	def get_address(self):
-		return self._address
-
-	def set_address(self, address):
-		if not address or not isinstance(address, unicode):
-			raise ValueError("address must be a unicode string")
-		self._address = address
-		self._properties['address'] = address
-
-	def get_domain(self):
-		"""Return the ZeroConf/mDNS domain the service was found in."""
-		return self._domain
-
-	def register(self, system_bus, avahi_service):
-		if self._avahi_entry_group is not None:
-			raise RuntimeError("Service already registered!")
-
-		obj = system_bus.get_object(avahi.DBUS_NAME, avahi_service.EntryGroupNew())
-		self._avahi_entry_group = dbus.Interface(obj, avahi.DBUS_INTERFACE_ENTRY_GROUP)
-
-		info = _convert_properties_to_dbus_byte_array(self._properties)
-		logging.debug("Will register service with name='%s', stype='%s'," \
-				" domain='%s', address='%s', port=%d, info='%s'" % (self._full_name,
-				self._stype, self._domain, self._address, self._port, info))
-
-		self._avahi_entry_group.AddService(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, 0,
-				dbus.String(self._full_name), dbus.String(self._stype),
-				dbus.String(self._domain), dbus.String(""), # let Avahi figure the 'host' out
-				dbus.UInt16(self._port), info)
-
-		self._avahi_entry_group.connect_to_signal('StateChanged', self.__entry_group_changed_cb)
-		self._avahi_entry_group.Commit()
-
-	def __entry_group_changed_cb(self, state, error):
-		pass
-#		logging.debug("** %s.%s Entry group changed: state %s, error %s" % (self._full_name, self._stype, state, error))
-
-	def unregister(self, sender):
-		# Refuse to unregister if we can't get the dbus connection this request
-		# came from for some reason
-		if not sender:
-			raise RuntimeError("Service registration request must have a sender.")
-		if not self._local_publisher:
-			raise ValueError("Service was not a local service provided by this laptop!")
-		if sender is not None and self._local_publisher != sender:
-			raise ValueError("Service was not registered by requesting process!")
-		if not self._avahi_entry_group:
-			raise ValueError("Service was not registered by requesting process!")
- 		self._avahi_entry_group.Free()
-		del self._avahi_entry_group
-		self._avahi_entry_group = None
+    """Encapsulates information about a specific ZeroConf/mDNS
+    service as advertised on the network."""
+
+    __gsignals__ = {
+        'property-changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
+                         ([gobject.TYPE_PYOBJECT]))
+    }
+
+    def __init__(self, bus_name, object_id, name, stype, domain=u"local",
+                address=None, port=-1, properties=None, source_address=None,
+                local_publisher=None):
+        gobject.GObject.__init__(self)
+        if not bus_name:
+            raise ValueError("DBus bus name must be valid")
+        if not object_id or not isinstance(object_id, int):
+            raise ValueError("object id must be a valid number")
+
+        # Validate immutable options
+        if name and not isinstance(name, unicode):
+            raise ValueError("name must be unicode.")
+        if not name or not len(name):
+            raise ValueError("must specify a valid service name.")
+
+        if stype and not isinstance(stype, unicode):
+            raise ValueError("service type must be in unicode.")
+        if not stype or not len(stype):
+            raise ValueError("must specify a valid service type.")
+        if not stype.endswith("._tcp") and not stype.endswith("._udp"):
+            raise ValueError("must specify a TCP or UDP service type.")
+
+        if not isinstance(domain, unicode):
+            raise ValueError("domain must be in unicode.")
+        if domain and domain != "local":
+            raise ValueError("must use the 'local' domain (for now).")
+
+        # ID of the D-Bus connection that published this service, if any.
+        # We only let the local publisher modify the service.
+        self._local_publisher = local_publisher
+
+        self._avahi_entry_group = None
+
+        (actid, real_name) = decompose_service_name(name)
+        self._name = real_name
+        self._full_name = name
+        self._stype = stype
+        self._domain = domain
+        self._port = -1
+        self.set_port(port)
+        self._properties = {}
+        self._dbus_helper = None
+        self._internal_set_properties(properties)
+
+        # Source address is the unicast source IP
+        self._source_address = None
+        if source_address is not None:
+            self.set_source_address(source_address)
+
+        # Address is the published address, could be multicast or unicast
+        self._address = None
+        if self._properties.has_key('address'):
+            self.set_address(self._properties['address'])
+        elif address is not None:
+            self.set_address(address)
+            self._properties['address'] = address
+
+        # Ensure that an ActivityID tag, if given, matches
+        # what we expect from the service type
+        if self._properties.has_key(_ACTIVITY_ID_TAG):
+            prop_actid = self._properties[_ACTIVITY_ID_TAG]
+            if (prop_actid and not actid) or (prop_actid != actid):
+                raise ValueError("ActivityID property specified, but the " \
+                        "service names's activity ID didn't match it: %s," \
+                        " %s" % (prop_actid, actid))
+        self._activity_id = actid
+        if actid and not self._properties.has_key(_ACTIVITY_ID_TAG):
+            self._properties[_ACTIVITY_ID_TAG] = actid
+
+        self._owner = None
+
+        # register ourselves with dbus
+        self._object_id = object_id
+        self._object_path = SERVICE_DBUS_OBJECT_PATH + str(self._object_id)
+        self._dbus_helper = ServiceDBusHelper(self, bus_name, self._object_path)
+
+    def object_path(self):
+        return dbus.ObjectPath(self._object_path)
+
+    def get_owner(self):
+        return self._owner
+
+    def set_owner(self, owner):
+        if self._owner is not None:
+            raise RuntimeError("Can only set a service's owner once")
+        self._owner = owner
+
+    def is_local(self):
+        if self._local_publisher is not None:
+            return True
+        return False
+
+    def get_name(self):
+        """Return the service's name, usually that of the
+        buddy who provides it."""
+        return self._name
+
+    def get_full_name(self):
+        return self._full_name
+
+    def get_one_property(self, key):
+        """Return one property of the service, or None
+        if the property was not found.  Cannot distinguish
+        between lack of a property, and a property value that
+        actually is None."""
+        if key in self._properties.keys():
+            return self._properties[key]
+        return None
+
+    def get_properties(self):
+        """Return a python dictionary of all the service's
+        properties."""
+        return self._properties
+
+    def __emit_properties_changed_signal(self, keys):
+        if self._dbus_helper:
+            self._dbus_helper.PublishedValueChanged(keys)
+        self.emit('property-changed', keys)
+
+    def set_property(self, key, value, sender=None):
+        """Set one service property"""
+        if not self._local_publisher:
+            raise ValueError("Service was not not registered by requesting process!")        
+        if sender is not None and self._local_publisher != sender:
+            raise ValueError("Service was not not registered by requesting process!")
+
+        if not isinstance(key, unicode):
+            raise ValueError("Key must be a unicode string.")
+        if not isinstance(value, unicode) and not isinstance(value, bool):
+            raise ValueError("Key must be a unicode string or a boolean.")
+
+        # Ignore setting the key to it's current value
+        if self._properties.has_key(key):
+            if self._properties[key] == value:
+                return
+
+        # Blank value means remove key
+        remove = False
+        if isinstance(value, unicode) and len(value) == 0:
+            remove = True
+        if isinstance(value, bool) and value == False:
+            remove = True
+
+        if remove:
+            # If the key wasn't present, return without error
+            if self._properties.has_key(key):
+                del self._properties[key]
+        else:
+            # Otherwise set it
+            if isinstance(value, bool):
+                value = ""
+            self._properties[key] = value
+
+        # if the service is locally published already, update the TXT records
+        if self._local_publisher and self._avahi_entry_group:
+            self.__internal_update_avahi_properties()
+
+        self.__emit_properties_changed_signal([key])
+
+    def set_properties(self, properties, sender=None, from_network=False):
+        """Set all service properties in one call"""
+        if sender is not None and self._local_publisher != sender:
+            raise ValueError("Service was not not registered by requesting process!")
+
+        self._internal_set_properties(properties, from_network)
+
+    def _internal_set_properties(self, properties, from_network=False):
+        """Set the service's properties from either an Avahi
+        TXT record (a list of lists of integers), or a
+        python dictionary."""
+        if not isinstance (properties, dict):
+            raise ValueError("Properties must be a dictionary.")
+
+        # Make sure the properties are actually different
+        diff_keys = _dicts_differ(self._properties, properties)
+        if len(diff_keys) == 0:
+            return
+
+        self._properties = {}
+        # Set key/value pairs on internal property list
+        for key, value in properties.items():
+            if len(key) == 0:
+                continue
+            tmp_key = key
+            tmp_val = value
+            if not isinstance(tmp_key, unicode):
+                tmp_key = unicode(tmp_key)
+            if not isinstance(tmp_val, unicode):
+                tmp_val = unicode(tmp_val)
+            self._properties[tmp_key] = tmp_val
+
+        # if the service is locally published already, update the TXT records
+        if self._local_publisher and self._avahi_entry_group and not from_network:
+            self.__internal_update_avahi_properties()
+
+        self.__emit_properties_changed_signal(diff_keys)
+
+    def __internal_update_avahi_properties(self):
+        info = _convert_properties_to_dbus_byte_array(self._properties)
+        self._avahi_entry_group.UpdateServiceTxt(avahi.IF_UNSPEC,
+                avahi.PROTO_UNSPEC, 0,
+                dbus.String(self._full_name), dbus.String(self._stype),
+                dbus.String(self._domain), info)
+
+    def get_type(self):
+        """Return the service's service type."""
+        return self._stype
+
+    def get_activity_id(self):
+        """Return the activity ID this service is associated with, if any."""
+        return self._activity_id
+
+    def get_port(self):
+        return self._port
+
+    def set_port(self, port):
+        if not isinstance(port, int) or (port <= 1024 and port > 65536):
+            raise ValueError("must specify a valid port number between 1024 and 65536.")
+        self._port = port
+
+    def get_source_address(self):
+        return self._source_address
+
+    def set_source_address(self, address):
+        if not address or not isinstance(address, unicode):
+            raise ValueError("address must be unicode")
+        self._source_address = address
+
+    def get_address(self):
+        return self._address
+
+    def set_address(self, address):
+        if not address or not isinstance(address, unicode):
+            raise ValueError("address must be a unicode string")
+        self._address = address
+        self._properties['address'] = address
+
+    def get_domain(self):
+        """Return the ZeroConf/mDNS domain the service was found in."""
+        return self._domain
+
+    def register(self, system_bus, avahi_service):
+        if self._avahi_entry_group is not None:
+            raise RuntimeError("Service already registered!")
+
+        obj = system_bus.get_object(avahi.DBUS_NAME, avahi_service.EntryGroupNew())
+        self._avahi_entry_group = dbus.Interface(obj, avahi.DBUS_INTERFACE_ENTRY_GROUP)
+
+        info = _convert_properties_to_dbus_byte_array(self._properties)
+        logging.debug("Will register service with name='%s', stype='%s'," \
+                " domain='%s', address='%s', port=%d, info='%s'" % (self._full_name,
+                self._stype, self._domain, self._address, self._port, info))
+
+        self._avahi_entry_group.AddService(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, 0,
+                dbus.String(self._full_name), dbus.String(self._stype),
+                dbus.String(self._domain), dbus.String(""), # let Avahi figure the 'host' out
+                dbus.UInt16(self._port), info)
+
+        self._avahi_entry_group.connect_to_signal('StateChanged', self.__entry_group_changed_cb)
+        self._avahi_entry_group.Commit()
+
+    def __entry_group_changed_cb(self, state, error):
+        pass
+#        logging.debug("** %s.%s Entry group changed: state %s, error %s" % (self._full_name, self._stype, state, error))
+
+    def unregister(self, sender):
+        # Refuse to unregister if we can't get the dbus connection this request
+        # came from for some reason
+        if not sender:
+            raise RuntimeError("Service registration request must have a sender.")
+        if not self._local_publisher:
+            raise ValueError("Service was not a local service provided by this laptop!")
+        if sender is not None and self._local_publisher != sender:
+            raise ValueError("Service was not registered by requesting process!")
+        if not self._avahi_entry_group:
+            raise ValueError("Service was not registered by requesting process!")
+         self._avahi_entry_group.Free()
+        del self._avahi_entry_group
+        self._avahi_entry_group = None
 
 
 #################################################################
@@ -450,153 +450,153 @@ import unittest
 
 __objid_seq = 0
 def _next_objid():
-	global __objid_seq
-	__objid_seq = __objid_seq + 1
-	return __objid_seq
+    global __objid_seq
+    __objid_seq = __objid_seq + 1
+    return __objid_seq
 
 
 class ServiceTestCase(unittest.TestCase):
-	_DEF_NAME = u"foobar"
-	_DEF_STYPE = u"_foo._bar._tcp"
-	_DEF_DOMAIN = u"local"
-	_DEF_ADDRESS = u"1.1.1.1"
-	_DEF_PORT = 1234
-	_DEF_PROPS = {'foobar': 'baz'}
-	_STR_TEST_ARGS = [None, 0, [], {}]
-
-	def __init__(self, name):
-		self._bus = dbus.SessionBus()
-		self._bus_name = dbus.service.BusName('org.laptop.Presence', bus=self._bus)		
-		unittest.TestCase.__init__(self, name)
-
-	def __del__(self):
-		del self._bus_name
-		del self._bus
-
-	def _test_init_fail(self, name, stype, domain, address, port, properties, fail_msg):
-		"""Test something we expect to fail."""
-		try:
-			objid = _next_objid()
-			service = Service(self._bus_name, objid, name, stype, domain, address,
-					port, properties)
-		except ValueError, exc:
-			pass
-		else:
-			self.fail("expected a ValueError for %s." % fail_msg)
-
-	def testName(self):
-		for item in self._STR_TEST_ARGS:
-			self._test_init_fail(item, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
-					self._DEF_PORT, self._DEF_PROPS, "invalid name")
-
-	def testType(self):
-		for item in self._STR_TEST_ARGS:
-			self._test_init_fail(self._DEF_NAME, item, self._DEF_DOMAIN, self._DEF_ADDRESS,
-					self._DEF_PORT, self._DEF_PROPS, "invalid service type")
-		self._test_init_fail(self._DEF_NAME, u"_bork._foobar", self._DEF_DOMAIN, self._DEF_ADDRESS,
-				self._DEF_PORT, self._DEF_PROPS, "invalid service type")
-
-	def testDomain(self):
-		for item in self._STR_TEST_ARGS:
-			self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, item, self._DEF_ADDRESS,
-					self._DEF_PORT, self._DEF_PROPS, "invalid domain")
-		# Only accept local for now
-		self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, u"foobar", self._DEF_ADDRESS,
-				self._DEF_PORT, self._DEF_PROPS, "invalid domain")
-		# Make sure "" works
-		objid = _next_objid()
-		service = Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, u"",
-				self._DEF_ADDRESS, self._DEF_PORT, self._DEF_PROPS)
-		assert service, "Empty domain was not accepted!"
-
-	def testAddress(self):
-		self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, [],
-				self._DEF_PORT, self._DEF_PROPS, "invalid address")
-		self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, {},
-				self._DEF_PORT, self._DEF_PROPS, "invalid address")
-		self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, 1234,
-				self._DEF_PORT, self._DEF_PROPS, "invalid address")
-
-	def testPort(self):
-		self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
-				[], self._DEF_PROPS, "invalid port")
-		self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
-				{}, self._DEF_PROPS, "invalid port")
-		self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
-				"adf", self._DEF_PROPS, "invalid port")
-
-	def testGoodInit(self):
-		objid = _next_objid()
-		service = Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN,
-				self._DEF_ADDRESS, self._DEF_PORT, self._DEF_PROPS)
-		assert service.get_name() == self._DEF_NAME, "service name wasn't correct after init."
-		assert service.get_type() == self._DEF_STYPE, "service type wasn't correct after init."
-		assert service.get_domain() == "local", "service domain wasn't correct after init."
-		assert service.get_address() == self._DEF_ADDRESS, "service address wasn't correct after init."
-		assert service.get_port() == self._DEF_PORT, "service port wasn't correct after init."
-		assert service.object_path() == SERVICE_DBUS_OBJECT_PATH + str(objid)
-		value = service.get_one_property('foobar')
-		assert value and value == 'baz', "service property wasn't correct after init."
-
-	def testAvahiProperties(self):
-		props = [[111, 114, 103, 46, 102, 114, 101, 101, 100, 101, 115, 107, 116, 111, 112, 46, 65, 118, 97, 104, 105, 46, 99, 111, 111, 107, 105, 101, 61, 50, 54, 48, 49, 53, 52, 51, 57, 53, 50]]
-		key = "org.freedesktop.Avahi.cookie"
-		expected_value = "2601543952"
-		objid = _next_objid()
-		service = Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN,
-				self._DEF_ADDRESS, self._DEF_PORT, props)
-		value = service.get_one_property(key)
-		assert value and value == expected_value, "service properties weren't correct after init."
-		value = service.get_one_property('bork')
-		assert not value, "service properties weren't correct after init."
-
-	def testBoolProperty(self):
-		props = [[111, 114, 103, 46, 102, 114, 101, 101, 100, 101, 115, 107, 116, 111, 112, 46, 65, 118, 97, 104, 105, 46, 99, 111, 111, 107, 105, 101]]
-		key = "org.freedesktop.Avahi.cookie"
-		expected_value = True
-		objid = _next_objid()
-		service = Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
-				self._DEF_PORT, props)
-		value = service.get_one_property(key)
-		assert value is not None and value == expected_value, "service properties weren't correct after init."
-
-	def testActivityService(self):
-		# Valid group service type, non-multicast address
-		actid = "4569a71b80805aa96a847f7ac1c407327b3ec2b4"
-		name = compose_service_name("Tommy", actid)
-
-		# Valid activity service name, None address
-		objid = _next_objid()
-		service = Service(self._bus_name, objid, name, self._DEF_STYPE, self._DEF_DOMAIN, None,
-				self._DEF_PORT, self._DEF_PROPS)
-		assert service.get_address() == None, "address was not None as expected!"
-		assert service.get_activity_id() == actid, "activity id was different than expected!"
-
-		# Valid activity service name and multicast address, ensure it works
-		mc_addr = u"224.0.0.34"
-		objid = _next_objid()
-		service = Service(self._bus_name, objid, name, self._DEF_STYPE, self._DEF_DOMAIN, mc_addr,
-				self._DEF_PORT, self._DEF_PROPS)
-		assert service.get_address() == mc_addr, "address was not expected address!"
-
-	def addToSuite(suite):
-		suite.addTest(ServiceTestCase("testName"))
-		suite.addTest(ServiceTestCase("testType"))
-		suite.addTest(ServiceTestCase("testDomain"))
-		suite.addTest(ServiceTestCase("testAddress"))
-		suite.addTest(ServiceTestCase("testPort"))
-		suite.addTest(ServiceTestCase("testGoodInit"))
-		suite.addTest(ServiceTestCase("testAvahiProperties"))
-		suite.addTest(ServiceTestCase("testBoolProperty"))
-		suite.addTest(ServiceTestCase("testActivityService"))
-	addToSuite = staticmethod(addToSuite)
+    _DEF_NAME = u"foobar"
+    _DEF_STYPE = u"_foo._bar._tcp"
+    _DEF_DOMAIN = u"local"
+    _DEF_ADDRESS = u"1.1.1.1"
+    _DEF_PORT = 1234
+    _DEF_PROPS = {'foobar': 'baz'}
+    _STR_TEST_ARGS = [None, 0, [], {}]
+
+    def __init__(self, name):
+        self._bus = dbus.SessionBus()
+        self._bus_name = dbus.service.BusName('org.laptop.Presence', bus=self._bus)        
+        unittest.TestCase.__init__(self, name)
+
+    def __del__(self):
+        del self._bus_name
+        del self._bus
+
+    def _test_init_fail(self, name, stype, domain, address, port, properties, fail_msg):
+        """Test something we expect to fail."""
+        try:
+            objid = _next_objid()
+            service = Service(self._bus_name, objid, name, stype, domain, address,
+                    port, properties)
+        except ValueError, exc:
+            pass
+        else:
+            self.fail("expected a ValueError for %s." % fail_msg)
+
+    def testName(self):
+        for item in self._STR_TEST_ARGS:
+            self._test_init_fail(item, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
+                    self._DEF_PORT, self._DEF_PROPS, "invalid name")
+
+    def testType(self):
+        for item in self._STR_TEST_ARGS:
+            self._test_init_fail(self._DEF_NAME, item, self._DEF_DOMAIN, self._DEF_ADDRESS,
+                    self._DEF_PORT, self._DEF_PROPS, "invalid service type")
+        self._test_init_fail(self._DEF_NAME, u"_bork._foobar", self._DEF_DOMAIN, self._DEF_ADDRESS,
+                self._DEF_PORT, self._DEF_PROPS, "invalid service type")
+
+    def testDomain(self):
+        for item in self._STR_TEST_ARGS:
+            self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, item, self._DEF_ADDRESS,
+                    self._DEF_PORT, self._DEF_PROPS, "invalid domain")
+        # Only accept local for now
+        self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, u"foobar", self._DEF_ADDRESS,
+                self._DEF_PORT, self._DEF_PROPS, "invalid domain")
+        # Make sure "" works
+        objid = _next_objid()
+        service = Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, u"",
+                self._DEF_ADDRESS, self._DEF_PORT, self._DEF_PROPS)
+        assert service, "Empty domain was not accepted!"
+
+    def testAddress(self):
+        self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, [],
+                self._DEF_PORT, self._DEF_PROPS, "invalid address")
+        self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, {},
+                self._DEF_PORT, self._DEF_PROPS, "invalid address")
+        self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, 1234,
+                self._DEF_PORT, self._DEF_PROPS, "invalid address")
+
+    def testPort(self):
+        self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
+                [], self._DEF_PROPS, "invalid port")
+        self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
+                {}, self._DEF_PROPS, "invalid port")
+        self._test_init_fail(self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
+                "adf", self._DEF_PROPS, "invalid port")
+
+    def testGoodInit(self):
+        objid = _next_objid()
+        service = Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN,
+                self._DEF_ADDRESS, self._DEF_PORT, self._DEF_PROPS)
+        assert service.get_name() == self._DEF_NAME, "service name wasn't correct after init."
+        assert service.get_type() == self._DEF_STYPE, "service type wasn't correct after init."
+        assert service.get_domain() == "local", "service domain wasn't correct after init."
+        assert service.get_address() == self._DEF_ADDRESS, "service address wasn't correct after init."
+        assert service.get_port() == self._DEF_PORT, "service port wasn't correct after init."
+        assert service.object_path() == SERVICE_DBUS_OBJECT_PATH + str(objid)
+        value = service.get_one_property('foobar')
+        assert value and value == 'baz', "service property wasn't correct after init."
+
+    def testAvahiProperties(self):
+        props = [[111, 114, 103, 46, 102, 114, 101, 101, 100, 101, 115, 107, 116, 111, 112, 46, 65, 118, 97, 104, 105, 46, 99, 111, 111, 107, 105, 101, 61, 50, 54, 48, 49, 53, 52, 51, 57, 53, 50]]
+        key = "org.freedesktop.Avahi.cookie"
+        expected_value = "2601543952"
+        objid = _next_objid()
+        service = Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN,
+                self._DEF_ADDRESS, self._DEF_PORT, props)
+        value = service.get_one_property(key)
+        assert value and value == expected_value, "service properties weren't correct after init."
+        value = service.get_one_property('bork')
+        assert not value, "service properties weren't correct after init."
+
+    def testBoolProperty(self):
+        props = [[111, 114, 103, 46, 102, 114, 101, 101, 100, 101, 115, 107, 116, 111, 112, 46, 65, 118, 97, 104, 105, 46, 99, 111, 111, 107, 105, 101]]
+        key = "org.freedesktop.Avahi.cookie"
+        expected_value = True
+        objid = _next_objid()
+        service = Service(self._bus_name, objid, self._DEF_NAME, self._DEF_STYPE, self._DEF_DOMAIN, self._DEF_ADDRESS,
+                self._DEF_PORT, props)
+        value = service.get_one_property(key)
+        assert value is not None and value == expected_value, "service properties weren't correct after init."
+
+    def testActivityService(self):
+        # Valid group service type, non-multicast address
+        actid = "4569a71b80805aa96a847f7ac1c407327b3ec2b4"
+        name = compose_service_name("Tommy", actid)
+
+        # Valid activity service name, None address
+        objid = _next_objid()
+        service = Service(self._bus_name, objid, name, self._DEF_STYPE, self._DEF_DOMAIN, None,
+                self._DEF_PORT, self._DEF_PROPS)
+        assert service.get_address() == None, "address was not None as expected!"
+        assert service.get_activity_id() == actid, "activity id was different than expected!"
+
+        # Valid activity service name and multicast address, ensure it works
+        mc_addr = u"224.0.0.34"
+        objid = _next_objid()
+        service = Service(self._bus_name, objid, name, self._DEF_STYPE, self._DEF_DOMAIN, mc_addr,
+                self._DEF_PORT, self._DEF_PROPS)
+        assert service.get_address() == mc_addr, "address was not expected address!"
+
+    def addToSuite(suite):
+        suite.addTest(ServiceTestCase("testName"))
+        suite.addTest(ServiceTestCase("testType"))
+        suite.addTest(ServiceTestCase("testDomain"))
+        suite.addTest(ServiceTestCase("testAddress"))
+        suite.addTest(ServiceTestCase("testPort"))
+        suite.addTest(ServiceTestCase("testGoodInit"))
+        suite.addTest(ServiceTestCase("testAvahiProperties"))
+        suite.addTest(ServiceTestCase("testBoolProperty"))
+        suite.addTest(ServiceTestCase("testActivityService"))
+    addToSuite = staticmethod(addToSuite)
 
 
 def main():
-	suite = unittest.TestSuite()
-	ServiceTestCase.addToSuite(suite)
-	runner = unittest.TextTestRunner()
-	runner.run(suite)
+    suite = unittest.TestSuite()
+    ServiceTestCase.addToSuite(suite)
+    runner = unittest.TextTestRunner()
+    runner.run(suite)
 
 if __name__ == "__main__":
-	main()
+    main()