Merge lp:~larsu/unity-control-center/bluez5-gnome-bluetooth into lp:unity-control-center

[Sebastien Bacher]

bluetooth: make compatible with bluez5

Since we don't want to update to gnome bluetooth's new UI, import
gnome-bluetooth until commit ef7d546, which has bluez5 support but no UI
changes.

bluetooth: make compatible with bluez5

Since we don't want to update to gnome bluetooth's new UI, import
gnome-bluetooth until commit ef7d546, which has bluez5 support but no UI
changes.

[Sebastien Bacher (seb128)]

Lars is not around, merge proposing for him, I stack a branch with some addition tweaks/fixes on top of that one. The changes could be nicer but that should do the job to unblock the bluez5 migration, we can iterate more later

review: Approve

=== modified file 'configure.ac'
--- configure.ac	2015-02-12 14:09:23 +0000
+++ configure.ac	2015-08-12 15:47:27 +0000
@@ -171,6 +171,7 @@
                   gdk-pixbuf-2.0 >= $GDKPIXBUF_REQUIRED_VERSION
                   pwquality
                   accountsservice >= $ACCOUNTSSERVICE_REQUIRED_VERSION)
+PKG_CHECK_MODULES(BLUETOOTH_PANEL, $COMMON_MODULES)
 
 AM_PROG_VALAC([0.20.0])
 
@@ -188,11 +189,6 @@
 fi
 AM_CONDITIONAL(BUILD_NETWORK, [test x$have_networkmanager = xyes])
 
-# Check for gnome-bluetooth
-PKG_CHECK_MODULES(BLUETOOTH, $COMMON_MODULES gnome-bluetooth-1.0 >= 3.5.5,
-		  [have_bluetooth=yes], have_bluetooth=no)
-AM_CONDITIONAL(BUILD_BLUETOOTH, [test x$have_bluetooth = xyes])
-
 # Check for CUPS 1.4 or newer
 AC_ARG_ENABLE([cups],
               AS_HELP_STRING([--disable-cups], [disable CUPS support (default: enabled)]),,
@@ -419,6 +415,9 @@
 panels/appearance/Makefile
 panels/appearance/unity-appearance-panel.desktop.in
 panels/bluetooth/Makefile
+panels/bluetooth/gnome-bluetooth/Makefile
+panels/bluetooth/gnome-bluetooth/lib/Makefile
+panels/bluetooth/gnome-bluetooth/wizard/Makefile
 panels/bluetooth/unity-bluetooth-panel.desktop.in
 panels/datetime/Makefile
 panels/datetime/unity-datetime-panel.desktop.in
@@ -502,11 +501,6 @@
 else
 	AC_MSG_NOTICE([   Network panel disabled])
 fi
-if test "x$have_bluetooth" = "xyes"; then
-	AC_MSG_NOTICE([** gnome-bluetooth (Bluetooth panel)])
-else
-	AC_MSG_NOTICE([   Bluetooth panel disabled])
-fi
 if test "x$enable_cups" = "xyes"; then
 	AC_MSG_NOTICE([** CUPS (Printers panel)])
 else

=== modified file 'panels/Makefile.am'
--- panels/Makefile.am	2014-02-10 22:19:33 +0000
+++ panels/Makefile.am	2015-08-12 15:47:27 +0000
@@ -12,7 +12,8 @@
 	sound \
 	keyboard \
 	universal-access \
-	user-accounts
+	user-accounts \
+	bluetooth
 
 if BUILD_WACOM
 SUBDIRS += wacom
@@ -26,8 +27,4 @@
 SUBDIRS += network
 endif
 
-if BUILD_BLUETOOTH
-SUBDIRS += bluetooth
-endif
-
 -include $(top_srcdir)/git.mk

=== modified file 'panels/bluetooth/Makefile.am'
--- panels/bluetooth/Makefile.am	2014-02-19 23:36:18 +0000
+++ panels/bluetooth/Makefile.am	2015-08-12 15:47:27 +0000
@@ -1,3 +1,5 @@
+SUBDIRS = gnome-bluetooth
+
 # This is used in PANEL_CFLAGS
 cappletname = bluetooth
 
@@ -6,7 +8,8 @@
 
 INCLUDES = 						\
 	$(PANEL_CFLAGS)					\
-	$(BLUETOOTH_CFLAGS)				\
+	$(BLUETOOTH_PANEL_CFLAGS)				\
+	-I$(srcdir)/gnome-bluetooth/lib			\
 	-DGNOMELOCALEDIR="\"$(datadir)/locale\""	\
 	$(NULL)
 
@@ -17,9 +20,18 @@
 libbluetooth_la_SOURCES =			\
 	$(BUILT_SOURCES)			\
 	cc-bluetooth-panel.c			\
-	cc-bluetooth-panel.h
-
-libbluetooth_la_LIBADD = $(PANEL_LIBS) $(BLUETOOTH_LIBS)
+	cc-bluetooth-panel.h			\
+	bluetooth-killswitch.c			\
+	bluetooth-killswitch.h			\
+	rfkill.h				\
+	rfkill-glib.c				\
+	rfkill-glib.h
+
+libbluetooth_la_LIBADD = \
+	$(PANEL_LIBS) \
+	$(BLUETOOTH_PANEL_LIBS) \
+	$(builddir)/gnome-bluetooth/lib/libgnome-bluetooth.la
+
 libbluetooth_la_LDFLAGS = $(PANEL_LDFLAGS)
 
 resource_files = $(shell glib-compile-resources --sourcedir=$(srcdir) --generate-dependencies $(srcdir)/bluetooth.gresource.xml)

=== added file 'panels/bluetooth/bluetooth-killswitch.c'
--- panels/bluetooth/bluetooth-killswitch.c	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/bluetooth-killswitch.c	2015-08-12 15:47:27 +0000
@@ -0,0 +1,387 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2005-2008  Marcel Holtmann <[e-mail]>
+ *  Copyright (C) 2006-2009  Bastien Nocera <[e-mail]>
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+/**
+ * SECTION:bluetooth-killswitch
+ * @short_description: a Bluetooth killswitch object
+ * @stability: Stable
+ * @include: bluetooth-killswitch.h
+ *
+ * An object to manipulate Bluetooth killswitches.
+ **/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <sys/types.h>
+#include <string.h>
+#include <glib.h>
+
+#include "bluetooth-killswitch.h"
+#include "rfkill-glib.h"
+
+enum {
+	STATE_CHANGED,
+	LAST_SIGNAL
+};
+
+static int signals[LAST_SIGNAL] = { 0 };
+
+#define BLUETOOTH_KILLSWITCH_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
+				BLUETOOTH_TYPE_KILLSWITCH, BluetoothKillswitchPrivate))
+
+typedef struct _BluetoothIndKillswitch BluetoothIndKillswitch;
+struct _BluetoothIndKillswitch {
+	guint index;
+	BluetoothKillswitchState state;
+};
+
+struct _BluetoothKillswitchPrivate {
+	RfkillGlib *rfkill;
+	gboolean in_init;
+	GList *killswitches; /* a GList of BluetoothIndKillswitch */
+	BluetoothKillswitchPrivate *priv;
+};
+
+G_DEFINE_TYPE(BluetoothKillswitch, bluetooth_killswitch, G_TYPE_OBJECT)
+
+static BluetoothKillswitchState
+event_to_state (guint soft, guint hard)
+{
+	if (hard)
+		return BLUETOOTH_KILLSWITCH_STATE_HARD_BLOCKED;
+	else if (soft)
+		return BLUETOOTH_KILLSWITCH_STATE_SOFT_BLOCKED;
+	else
+		return BLUETOOTH_KILLSWITCH_STATE_UNBLOCKED;
+}
+
+static const char *
+state_to_string (BluetoothKillswitchState state)
+{
+	switch (state) {
+	case BLUETOOTH_KILLSWITCH_STATE_NO_ADAPTER:
+		return "no-adapter";
+	case BLUETOOTH_KILLSWITCH_STATE_SOFT_BLOCKED:
+		return "soft-blocked";
+	case BLUETOOTH_KILLSWITCH_STATE_UNBLOCKED:
+		return "unblocked";
+	case BLUETOOTH_KILLSWITCH_STATE_HARD_BLOCKED:
+		return "hard-blocked";
+	default:
+		g_assert_not_reached ();
+	}
+}
+
+const char *
+bluetooth_killswitch_state_to_string (BluetoothKillswitchState state)
+{
+	g_return_val_if_fail (state >= BLUETOOTH_KILLSWITCH_STATE_NO_ADAPTER, NULL);
+	g_return_val_if_fail (state <= BLUETOOTH_KILLSWITCH_STATE_HARD_BLOCKED, NULL);
+
+	return state_to_string (state);
+}
+
+static void
+update_killswitch (BluetoothKillswitch *killswitch,
+		   guint index, guint soft, guint hard)
+{
+	BluetoothKillswitchPrivate *priv;
+	gboolean changed;
+	GList *l;
+
+	priv = killswitch->priv;
+	changed = FALSE;
+
+	for (l = priv->killswitches; l != NULL; l = l->next) {
+		BluetoothIndKillswitch *ind = l->data;
+
+		if (ind->index == index) {
+			BluetoothKillswitchState state = event_to_state (soft, hard);
+			if (state != ind->state) {
+				ind->state = state;
+				changed = TRUE;
+			}
+			break;
+		}
+	}
+
+	if (changed != FALSE) {
+		g_debug ("updating killswitch status %d to %s",
+			 index, state_to_string (bluetooth_killswitch_get_state (killswitch)));
+		g_signal_emit (G_OBJECT (killswitch),
+			       signals[STATE_CHANGED],
+			       0, bluetooth_killswitch_get_state (killswitch));
+	}
+}
+
+void
+bluetooth_killswitch_set_state (BluetoothKillswitch *killswitch,
+				BluetoothKillswitchState state)
+{
+	BluetoothKillswitchPrivate *priv;
+	struct rfkill_event event;
+	ssize_t len;
+
+	g_return_if_fail (BLUETOOTH_IS_KILLSWITCH (killswitch));
+	g_return_if_fail (state != BLUETOOTH_KILLSWITCH_STATE_HARD_BLOCKED);
+
+	priv = killswitch->priv;
+
+	memset (&event, 0, sizeof(event));
+	event.op = RFKILL_OP_CHANGE_ALL;
+	event.type = RFKILL_TYPE_BLUETOOTH;
+	if (state == BLUETOOTH_KILLSWITCH_STATE_SOFT_BLOCKED)
+		event.soft = 1;
+	else if (state == BLUETOOTH_KILLSWITCH_STATE_UNBLOCKED)
+		event.soft = 0;
+	else
+		g_assert_not_reached ();
+
+	len = rfkill_glib_send_event (priv->rfkill, &event);
+	if (len < 0)
+		g_warning ("Failed to change RFKILL state: %s",
+			   g_strerror (errno));
+}
+
+BluetoothKillswitchState
+bluetooth_killswitch_get_state (BluetoothKillswitch *killswitch)
+{
+	BluetoothKillswitchPrivate *priv;
+	int state = BLUETOOTH_KILLSWITCH_STATE_UNBLOCKED;
+	GList *l;
+
+	g_return_val_if_fail (BLUETOOTH_IS_KILLSWITCH (killswitch), state);
+
+	priv = killswitch->priv;
+
+	if (priv->killswitches == NULL)
+		return BLUETOOTH_KILLSWITCH_STATE_NO_ADAPTER;
+
+	for (l = priv->killswitches ; l ; l = l->next) {
+		BluetoothIndKillswitch *ind = l->data;
+
+		g_debug ("killswitch %d is %s",
+			 ind->index, state_to_string (ind->state));
+
+		if (ind->state == BLUETOOTH_KILLSWITCH_STATE_HARD_BLOCKED) {
+			state = BLUETOOTH_KILLSWITCH_STATE_HARD_BLOCKED;
+			break;
+		}
+
+		if (ind->state == BLUETOOTH_KILLSWITCH_STATE_SOFT_BLOCKED) {
+			state = BLUETOOTH_KILLSWITCH_STATE_SOFT_BLOCKED;
+			continue;
+		}
+
+		state = ind->state;
+	}
+
+	g_debug ("killswitches state %s", state_to_string (state));
+
+	return state;
+}
+
+gboolean
+bluetooth_killswitch_has_killswitches (BluetoothKillswitch *killswitch)
+{
+	BluetoothKillswitchPrivate *priv = killswitch->priv;
+
+	g_return_val_if_fail (BLUETOOTH_IS_KILLSWITCH (killswitch), FALSE);
+
+	return (priv->killswitches != NULL);
+}
+
+static void
+remove_killswitch (BluetoothKillswitch *killswitch,
+		   guint index)
+{
+	BluetoothKillswitchPrivate *priv;
+	GList *l;
+
+	priv = killswitch->priv;
+
+	for (l = priv->killswitches; l != NULL; l = l->next) {
+		BluetoothIndKillswitch *ind = l->data;
+		if (ind->index == index) {
+			priv->killswitches = g_list_remove (priv->killswitches, ind);
+			g_debug ("removing killswitch idx %d", index);
+			g_free (ind);
+			g_signal_emit (G_OBJECT (killswitch),
+				       signals[STATE_CHANGED],
+				       0, bluetooth_killswitch_get_state (killswitch));
+			return;
+		}
+	}
+}
+
+static void
+add_killswitch (BluetoothKillswitch *killswitch,
+		guint index,
+		BluetoothKillswitchState state)
+
+{
+	BluetoothKillswitchPrivate *priv;
+	BluetoothIndKillswitch *ind;
+
+	priv = killswitch->priv;
+
+	g_debug ("adding killswitch idx %d state %s", index, state_to_string (state));
+	ind = g_new0 (BluetoothIndKillswitch, 1);
+	ind->index = index;
+	ind->state = state;
+	priv->killswitches = g_list_append (priv->killswitches, ind);
+}
+
+static void
+killswitch_changed (RfkillGlib          *rfkill,
+		    GList               *events,
+		    BluetoothKillswitch *killswitch)
+{
+	BluetoothKillswitchState state;
+	gboolean changed;
+	GList *l;
+
+	if (killswitch->priv->in_init) {
+		for (l = events; l != NULL; l = l->next) {
+			struct rfkill_event *event = l->data;
+
+			if (event->op != RFKILL_OP_ADD)
+				continue;
+			if (event->type != RFKILL_TYPE_BLUETOOTH)
+				continue;
+
+			state = event_to_state (event->soft, event->hard);
+
+			g_debug ("Read killswitch (idx=%d): %s",
+				 event->idx, bluetooth_killswitch_state_to_string (state));
+
+			add_killswitch (killswitch, event->idx, state);
+		}
+
+		g_signal_emit (G_OBJECT (killswitch),
+			       signals[STATE_CHANGED],
+			       0, bluetooth_killswitch_get_state (killswitch));
+		return;
+	}
+
+	changed = FALSE;
+
+	/* Gather the previous killswitch so we can
+	 * see what really changed */
+	state = bluetooth_killswitch_get_state (killswitch);
+
+	for (l = events; l != NULL; l = l->next) {
+		struct rfkill_event *event = l->data;
+
+		if (event->type != RFKILL_TYPE_BLUETOOTH &&
+		    event->type != RFKILL_TYPE_ALL)
+			continue;
+
+		if (event->op == RFKILL_OP_CHANGE) {
+			update_killswitch (killswitch, event->idx, event->soft, event->hard);
+			/* No changed here because update_killswitch
+			 * handles sending the state-changed signal */
+		} else if (event->op == RFKILL_OP_DEL) {
+			remove_killswitch (killswitch, event->idx);
+			changed = TRUE;
+		} else if (event->op == RFKILL_OP_ADD) {
+			BluetoothKillswitchState state;
+			state = event_to_state (event->soft, event->hard);
+			add_killswitch (killswitch, event->idx, state);
+			changed = TRUE;
+		}
+	}
+
+	if (changed) {
+		BluetoothKillswitchState new_state;
+
+		new_state = bluetooth_killswitch_get_state (killswitch);
+		if (new_state != state) {
+			g_signal_emit (G_OBJECT (killswitch),
+				       signals[STATE_CHANGED],
+				       0, bluetooth_killswitch_get_state (killswitch));
+		}
+	}
+}
+
+static void
+bluetooth_killswitch_init (BluetoothKillswitch *killswitch)
+{
+	BluetoothKillswitchPrivate *priv;
+
+	priv = BLUETOOTH_KILLSWITCH_GET_PRIVATE (killswitch);
+	killswitch->priv = priv;
+
+	priv->rfkill = rfkill_glib_new ();
+	g_signal_connect (priv->rfkill, "changed",
+			  G_CALLBACK (killswitch_changed), killswitch);
+
+	priv->in_init = TRUE;
+	if (rfkill_glib_open (priv->rfkill) < 0)
+		return;
+	priv->in_init = FALSE;
+}
+
+static void
+bluetooth_killswitch_finalize (GObject *object)
+{
+	BluetoothKillswitch *killswitch;
+
+	killswitch = BLUETOOTH_KILLSWITCH (object);
+
+	g_clear_object (&killswitch->priv->rfkill);
+
+	g_list_free_full (killswitch->priv->killswitches, g_free);
+	killswitch->priv->killswitches = NULL;
+
+	G_OBJECT_CLASS(bluetooth_killswitch_parent_class)->finalize(object);
+}
+
+static void
+bluetooth_killswitch_class_init(BluetoothKillswitchClass *klass)
+{
+	GObjectClass *object_class = (GObjectClass *) klass;
+
+	g_type_class_add_private(klass, sizeof(BluetoothKillswitchPrivate));
+	object_class->finalize = bluetooth_killswitch_finalize;
+
+	signals[STATE_CHANGED] =
+		g_signal_new ("state-changed",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (BluetoothKillswitchClass, state_changed),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__INT,
+			      G_TYPE_NONE, 1, G_TYPE_INT);
+
+}
+
+BluetoothKillswitch *
+bluetooth_killswitch_new (void)
+{
+	return BLUETOOTH_KILLSWITCH (g_object_new (BLUETOOTH_TYPE_KILLSWITCH, NULL));
+}

=== added file 'panels/bluetooth/bluetooth-killswitch.h'
--- panels/bluetooth/bluetooth-killswitch.h	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/bluetooth-killswitch.h	2015-08-12 15:47:27 +0000
@@ -0,0 +1,78 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2005-2008  Marcel Holtmann <[e-mail]>
+ *  Copyright (C) 2006-2009  Bastien Nocera <[e-mail]>
+ *
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef __BLUETOOTH_KILLSWITCH_H
+#define __BLUETOOTH_KILLSWITCH_H
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+typedef enum {
+	BLUETOOTH_KILLSWITCH_STATE_NO_ADAPTER = -1,
+	BLUETOOTH_KILLSWITCH_STATE_SOFT_BLOCKED = 0,
+	BLUETOOTH_KILLSWITCH_STATE_UNBLOCKED,
+	BLUETOOTH_KILLSWITCH_STATE_HARD_BLOCKED
+} BluetoothKillswitchState;
+
+#define BLUETOOTH_TYPE_KILLSWITCH (bluetooth_killswitch_get_type())
+#define BLUETOOTH_KILLSWITCH(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+					BLUETOOTH_TYPE_KILLSWITCH, BluetoothKillswitch))
+#define BLUETOOTH_KILLSWITCH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), \
+					BLUETOOTH_TYPE_KILLSWITCH, BluetoothKillswitchClass))
+#define BLUETOOTH_IS_KILLSWITCH(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+							BLUETOOTH_TYPE_KILLSWITCH))
+#define BLUETOOTH_IS_KILLSWITCH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), \
+							BLUETOOTH_TYPE_KILLSWITCH))
+#define BLUETOOTH_GET_KILLSWITCH_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), \
+					BLUETOOTH_TYPE_KILLSWITCH, BluetoothKillswitchClass))
+
+typedef struct _BluetoothKillswitch BluetoothKillswitch;
+typedef struct _BluetoothKillswitchClass BluetoothKillswitchClass;
+typedef struct _BluetoothKillswitchPrivate BluetoothKillswitchPrivate;
+
+struct _BluetoothKillswitch {
+	GObject parent;
+	BluetoothKillswitchPrivate *priv;
+};
+
+struct _BluetoothKillswitchClass {
+	GObjectClass parent_class;
+
+	void (*state_changed) (BluetoothKillswitch *killswitch, BluetoothKillswitchState state);
+};
+
+GType bluetooth_killswitch_get_type(void);
+
+BluetoothKillswitch * bluetooth_killswitch_new (void);
+
+gboolean                  bluetooth_killswitch_has_killswitches (BluetoothKillswitch *killswitch);
+void                      bluetooth_killswitch_set_state        (BluetoothKillswitch *killswitch,
+								 BluetoothKillswitchState state);
+BluetoothKillswitchState  bluetooth_killswitch_get_state        (BluetoothKillswitch *killswitch);
+const char               *bluetooth_killswitch_state_to_string  (BluetoothKillswitchState state);
+
+G_END_DECLS
+
+#endif /* __BLUETOOTH_KILLSWITCH_H */

=== modified file 'panels/bluetooth/cc-bluetooth-panel.c'
--- panels/bluetooth/cc-bluetooth-panel.c	2015-04-02 04:53:12 +0000
+++ panels/bluetooth/cc-bluetooth-panel.c	2015-08-12 15:47:27 +0000
@@ -35,7 +35,6 @@
 #include <bluetooth-utils.h>
 #include <bluetooth-killswitch.h>
 #include <bluetooth-chooser.h>
-#include <bluetooth-plugin-manager.h>
 
 CC_PANEL_REGISTER (CcBluetoothPanel, cc_bluetooth_panel)
 
@@ -102,8 +101,6 @@
 {
 	CcBluetoothPanel *self;
 
-	bluetooth_plugin_manager_cleanup ();
-
 	self = CC_BLUETOOTH_PANEL (object);
 	g_cancellable_cancel (self->priv->cancellable);
 	g_clear_object (&self->priv->cancellable);
@@ -260,37 +257,6 @@
 }
 
 static void
-add_extra_setup_widgets (CcBluetoothPanel *self,
-			 const char       *bdaddr)
-{
-	GValue value = { 0 };
-	char **uuids;
-	GList *list, *l;
-	GtkWidget *container;
-
-	if (bluetooth_chooser_get_selected_device_info (BLUETOOTH_CHOOSER (self->priv->chooser),
-							"uuids", &value) == FALSE)
-		return;
-
-	uuids = (char **) g_value_get_boxed (&value);
-	list = bluetooth_plugin_manager_get_widgets (bdaddr, (const char **) uuids);
-	if (list == NULL) {
-		g_value_unset (&value);
-		return;
-	}
-
-	container = WID ("additional_setup_box");
-	for (l = list; l != NULL; l = l->next) {
-		GtkWidget *widget = l->data;
-		gtk_box_pack_start (GTK_BOX (container), widget,
-				    FALSE, FALSE, 0);
-		gtk_widget_show_all (widget);
-	}
-	gtk_widget_show (container);
-	g_value_unset (&value);
-}
-
-static void
 remove_extra_setup_widgets (CcBluetoothPanel *self)
 {
 	GtkWidget *box;
@@ -397,10 +363,6 @@
 			;
 		}
 
-		/* Extra widgets */
-		if (g_strcmp0 (self->priv->selected_bdaddr, bdaddr) != 0)
-			add_extra_setup_widgets (self, bdaddr);
-
 		gtk_label_set_text (GTK_LABEL (WID ("address_label")), bdaddr);
 
 		gtk_widget_set_sensitive (WID ("button_delete"), TRUE);
@@ -544,34 +506,6 @@
 	g_free (alias);
 }
 
-static void
-mount_finish_cb (GObject *source_object,
-		 GAsyncResult *res,
-		 gpointer user_data)
-{
-	GError *error = NULL;
-
-	if (bluetooth_browse_address_finish (source_object, res, &error) == FALSE) {
-		g_printerr ("Failed to mount OBEX volume: %s", error->message);
-		g_error_free (error);
-		return;
-	}
-}
-
-static void
-browse_callback (GtkButton        *button,
-		 CcBluetoothPanel *self)
-{
-	char *bdaddr;
-
-	bdaddr = bluetooth_chooser_get_selected_device (BLUETOOTH_CHOOSER (self->priv->chooser));
-
-	bluetooth_browse_address (G_OBJECT (self), bdaddr,
-				  GDK_CURRENT_TIME, mount_finish_cb, NULL);
-
-	g_free (bdaddr);
-}
-
 /* Visibility/Discoverable */
 static void discoverable_changed (BluetoothClient  *client,
 				  GParamSpec       *spec,
@@ -693,7 +627,7 @@
 						       NULL,
 						       "org.bluez",
 						       adapter,
-						       "org.bluez.Adapter",
+						       "org.bluez.Adapter1",
 						       NULL,
 						       &error);
 	g_free (adapter);
@@ -736,10 +670,8 @@
 
 	name = bluetooth_chooser_get_selected_device_name (BLUETOOTH_CHOOSER (self->priv->chooser));
 
-	if (show_confirm_dialog (self, name) != FALSE) {
-		if (remove_selected_device (self))
-			bluetooth_plugin_manager_device_deleted (address);
-	}
+	if (show_confirm_dialog (self, name) != FALSE)
+		remove_selected_device (self);
 
 	g_free (address);
 	g_free (name);
@@ -828,7 +760,6 @@
 	self->priv = BLUETOOTH_PANEL_PRIVATE (self);
 	g_resources_register (cc_bluetooth_get_resource ());
 
-	bluetooth_plugin_manager_init ();
 	self->priv->cancellable = g_cancellable_new ();
 	self->priv->killswitch = bluetooth_killswitch_new ();
 	self->priv->client = bluetooth_client_new ();
@@ -914,8 +845,6 @@
 			  G_CALLBACK (keyboard_callback), self);
 	g_signal_connect (G_OBJECT (WID ("sound_link")), "activate-link",
 			  G_CALLBACK (sound_callback), self);
-	g_signal_connect (G_OBJECT (WID ("browse_button")), "clicked",
-			  G_CALLBACK (browse_callback), self);
 	g_signal_connect (G_OBJECT (WID ("send_button")), "clicked",
 			  G_CALLBACK (send_callback), self);
 	g_signal_connect (G_OBJECT (WID ("switch_connection")), "notify::active",

=== added directory 'panels/bluetooth/gnome-bluetooth'
=== added file 'panels/bluetooth/gnome-bluetooth/Makefile.am'
--- panels/bluetooth/gnome-bluetooth/Makefile.am	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/gnome-bluetooth/Makefile.am	2015-08-12 15:47:27 +0000
@@ -0,0 +1,1 @@
+SUBDIRS = lib wizard

=== added directory 'panels/bluetooth/gnome-bluetooth/lib'
=== added file 'panels/bluetooth/gnome-bluetooth/lib/Makefile.am'
--- panels/bluetooth/gnome-bluetooth/lib/Makefile.am	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/gnome-bluetooth/lib/Makefile.am	2015-08-12 15:47:27 +0000
@@ -0,0 +1,99 @@
+EXTRA_DIST = 
+CLEANFILES =
+
+lib_LTLIBRARIES = libgnome-bluetooth.la
+
+# will be scanned for introspection annotation, but won't be installed
+libgnome_bluetooth_c_sources =		\
+	bluetooth-client.c		\
+	bluetooth-utils.c		\
+	bluetooth-agent.c		\
+	gnome-bluetooth-enum-types.c	\
+	bluetooth-chooser.c		\
+	bluetooth-filter-widget.c	\
+	bluetooth-chooser-button.c	\
+	bluetooth-chooser-combo.c	\
+	bluetooth-client-glue.c		\
+	bluetooth-fdo-glue.c
+
+libgnome_bluetooth_private_headers =	\
+	bluetooth-client-private.h	\
+	bluetooth-agent.h		\
+	gnome-bluetooth-enum-types.h	\
+	bluetooth-chooser-private.h	\
+	bluetooth-client-glue.h		\
+	bluetooth-fdo-glue.h
+
+# public headers don't need to be listed, are handled by _HEADERS
+libgnome_bluetooth_la_SOURCES =			\
+	$(libgnome_bluetooth_private_headers)	\
+	$(libgnome_bluetooth_c_sources)
+
+libgnome_bluetooth_la_LIBADD = $(BLUETOOTH_PANEL_LIBS)
+
+libgnome_bluetooth_introspect_headers =			\
+	bluetooth-client.h				\
+	bluetooth-chooser.h				\
+	bluetooth-chooser-button.h			\
+	bluetooth-chooser-combo.h			\
+	bluetooth-filter-widget.h			\
+	bluetooth-enums.h				\
+	bluetooth-utils.h
+
+gnomebluetoothdir = $(pkgincludedir)
+gnomebluetooth_HEADERS = $(libgnome_bluetooth_introspect_headers)
+
+AM_CFLAGS =						\
+	-I$(srcdir)					\
+	$(BLUETOOTH_PANEL_CFLAGS)			\
+	$(WARN_CFLAGS)					\
+	$(DISABLE_DEPRECATED)				\
+	-DG_LOG_DOMAIN=\"Bluetooth\"
+
+BUILT_SOURCES = bluetooth-client-glue.h \
+		bluetooth-client-glue.c \
+		bluetooth-fdo-glue.h \
+		bluetooth-fdo-glue.c \
+		gnome-bluetooth-enum-types.h \
+		gnome-bluetooth-enum-types.c
+
+CLEANFILES += $(BUILT_SOURCES)
+
+EXTRA_DIST += bluetooth-client.xml bluetooth-fdo.xml
+
+MAINTAINERCLEANFILES = Makefile.in
+
+bluetooth-client-glue.c: bluetooth-client-glue.h
+
+bluetooth-client-glue.c bluetooth-client-glue.h: bluetooth-client.xml
+	$(AM_V_GEN) gdbus-codegen --c-namespace= --generate-c-code=bluetooth-client-glue --interface-prefix=org.bluez $<
+
+bluetooth-fdo-glue.c: bluetooth-fdo-glue.h
+
+bluetooth-fdo-glue.c bluetooth-fdo-glue.h: bluetooth-fdo.xml
+	$(AM_V_GEN) gdbus-codegen --c-namespace= --generate-c-code=bluetooth-fdo-glue --interface-prefix=org.freedesktop.DBus $<
+
+gnome_bluetooth_headers_to_scan_for_enums = bluetooth-enums.h
+# Generate the enums source code, with glib-mkenums:
+# This is based on the same Makefile.am stuff in pango:
+gnome_bluetooth_built_headers = gnome-bluetooth-enum-types.h
+gnome_bluetooth_built_cfiles = gnome-bluetooth-enum-types.c
+
+gnome-bluetooth-enum-types.h: $(gnome_bluetooth_headers_to_scan_for_enums) Makefile
+	$(AM_V_GEN) (cd $(srcdir) && glib-mkenums \
+			--fhead "#ifndef __GNOME_BLUETOOTH_ENUM_TYPES_H__\n#define __GNOME_BLUETOOTH_ENUM_TYPES_H__\n\n#include <glib-object.h>\n\nG_BEGIN_DECLS\n" \
+			--fprod "/* enumerations from \"@filename@\" */\n" \
+			--vhead "GType @enum_name@_get_type (void);\n#define BLUETOOTH_TYPE_@ENUMSHORT@ (@enum_name@_get_type())\n" 	\
+			--ftail "G_END_DECLS\n\n#endif /* __GNOME_BLUETOOTH_ENUM_TYPES_H__ */" \
+		$(gnome_bluetooth_headers_to_scan_for_enums)) > $@
+
+gnome-bluetooth-enum-types.c: $(gnome_bluetooth_headers_to_scan_for_enums) Makefile gnome-bluetooth-enum-types.h
+	$(AM_V_GEN) (cd $(srcdir) && glib-mkenums \
+			--fhead "#include <bluetooth-enums.h>\n" \
+			--fhead "#include \"gnome-bluetooth-enum-types.h\"\n" \
+			--fhead "#include <glib-object.h>" \
+		      	--fprod "\n/* enumerations from \"@filename@\" */" \
+			--vhead "GType\n@enum_name@_get_type (void)\n{\n  static GType etype = 0;\n  if (etype == 0) {\n    static const G@Type@Value values[] = {" 	\
+			--vprod "      { @VALUENAME@, \"@VALUENAME@\", \"@valuenick@\" }," \
+			--vtail "      { 0, NULL, NULL }\n    };\n    etype = g_@type@_register_static (\"@EnumName@\", values);\n  }\n  return etype;\n}\n" \
+		$(gnome_bluetooth_headers_to_scan_for_enums)) > $@

=== added file 'panels/bluetooth/gnome-bluetooth/lib/bluetooth-agent.c'
--- panels/bluetooth/gnome-bluetooth/lib/bluetooth-agent.c	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/gnome-bluetooth/lib/bluetooth-agent.c	2015-08-12 15:47:27 +0000
@@ -0,0 +1,681 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2005-2008  Marcel Holtmann <[e-mail]>
+ *
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <gio/gio.h>
+
+#include "bluetooth-client-glue.h"
+#include "bluetooth-fdo-glue.h"
+#include "bluetooth-agent.h"
+
+#define BLUEZ_SERVICE			"org.bluez"
+#define BLUEZ_AGENT_PATH		"/org/bluez/agent/gnome"
+#define BLUEZ_MANAGER_PATH		"/"
+
+static const gchar introspection_xml[] =
+"<node name='/'>"
+"  <interface name='org.bluez.Agent1'>"
+"    <method name='Release'/>"
+"    <method name='RequestPinCode'>"
+"      <arg type='o' name='device' direction='in'/>"
+"      <arg type='s' name='pincode' direction='out'/>"
+"    </method>"
+"    <method name='RequestPasskey'>"
+"      <arg type='o' name='device' direction='in'/>"
+"      <arg type='u' name='passkey' direction='out'/>"
+"    </method>"
+"    <method name='DisplayPasskey'>"
+"      <arg type='o' name='device' direction='in'/>"
+"      <arg type='u' name='passkey' direction='in'/>"
+"      <arg type='y' name='entered' direction='in'/>"
+"    </method>"
+"    <method name='DisplayPinCode'>"
+"      <arg type='o' name='device' direction='in'/>"
+"      <arg type='s' name='pincode' direction='in'/>"
+"    </method>"
+"    <method name='RequestConfirmation'>"
+"      <arg type='o' name='device' direction='in'/>"
+"      <arg type='u' name='passkey' direction='in'/>"
+"    </method>"
+"    <method name='RequestAuthorization'>"
+"      <arg type='o' name='device' direction='in'/>"
+"    </method>"
+"    <method name='AuthorizeService'>"
+"      <arg type='o' name='device' direction='in'/>"
+"      <arg type='s' name='uuid' direction='in'/>"
+"    </method>"
+"    <method name='Cancel'/>"
+"  </interface>"
+"</node>";
+
+#define BLUETOOTH_AGENT_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
+				BLUETOOTH_TYPE_AGENT, BluetoothAgentPrivate))
+
+typedef struct _BluetoothAgentPrivate BluetoothAgentPrivate;
+
+struct _BluetoothAgentPrivate {
+	GDBusConnection *conn;
+	gchar *busname;
+	gchar *path;
+	AgentManager1 *agent_manager;
+	GDBusNodeInfo *introspection_data;
+	guint reg_id;
+	guint watch_id;
+
+	BluetoothAgentPasskeyFunc pincode_func;
+	gpointer pincode_data;
+
+	BluetoothAgentDisplayFunc display_func;
+	gpointer display_data;
+
+	BluetoothAgentDisplayPinCodeFunc display_pincode_func;
+	gpointer display_pincode_data;
+
+	BluetoothAgentPasskeyFunc passkey_func;
+	gpointer passkey_data;
+
+	BluetoothAgentConfirmFunc confirm_func;
+	gpointer confirm_data;
+
+	BluetoothAgentAuthorizeFunc authorize_func;
+	gpointer authorize_data;
+
+	BluetoothAgentAuthorizeServiceFunc authorize_service_func;
+	gpointer authorize_service_data;
+
+	BluetoothAgentCancelFunc cancel_func;
+	gpointer cancel_data;
+};
+
+static GDBusProxy *get_device_from_path (const char *path)
+{
+	Device1 *device;
+	device = device1_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+						 G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+						 BLUEZ_SERVICE,
+						 path,
+						 NULL,
+						 NULL);
+
+	return G_DBUS_PROXY(device);
+}
+
+G_DEFINE_TYPE(BluetoothAgent, bluetooth_agent, G_TYPE_OBJECT)
+
+static gboolean bluetooth_agent_request_pincode(BluetoothAgent *agent,
+			const char *path, GDBusMethodInvocation *invocation)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	GDBusProxy *device;
+
+	if (priv->pincode_func == NULL)
+		return FALSE;
+
+	device = get_device_from_path(path);
+	if (device == NULL)
+		return FALSE;
+
+	priv->pincode_func(invocation, device, priv->pincode_data);
+
+	g_object_unref(device);
+
+	return TRUE;
+}
+
+static gboolean bluetooth_agent_request_passkey(BluetoothAgent *agent,
+			const char *path, GDBusMethodInvocation *invocation)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	GDBusProxy *device;
+
+	if (priv->passkey_func == NULL)
+		return FALSE;
+
+	device = get_device_from_path(path);
+	if (device == NULL)
+		return FALSE;
+
+	priv->passkey_func(invocation, device, priv->passkey_data);
+
+	g_object_unref(device);
+
+	return TRUE;
+}
+
+static gboolean bluetooth_agent_display_passkey(BluetoothAgent *agent,
+			const char *path, guint passkey, guint8 entered,
+						GDBusMethodInvocation *invocation)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	GDBusProxy *device;
+
+	if (priv->display_func == NULL)
+		return FALSE;
+
+	device = get_device_from_path(path);
+	if (device == NULL)
+		return FALSE;
+
+	priv->display_func(invocation, device, passkey, entered,
+			   priv->display_data);
+
+	g_object_unref(device);
+
+	return TRUE;
+}
+
+static gboolean bluetooth_agent_display_pincode(BluetoothAgent *agent,
+						const char *path, const char *pincode,
+						GDBusMethodInvocation *invocation)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	GDBusProxy *device;
+
+	if (priv->display_pincode_func == NULL)
+		return FALSE;
+
+	device = get_device_from_path(path);
+	if (device == NULL)
+		return FALSE;
+
+	priv->display_pincode_func(invocation, device, pincode,
+				   priv->display_data);
+
+	g_object_unref(device);
+
+	return TRUE;
+}
+
+static gboolean bluetooth_agent_request_confirmation(BluetoothAgent *agent,
+					const char *path, guint passkey,
+						GDBusMethodInvocation *invocation)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	GDBusProxy *device;
+
+	if (priv->confirm_func == NULL)
+		return FALSE;
+
+	device = get_device_from_path(path);
+	if (device == NULL)
+		return FALSE;
+
+	priv->confirm_func(invocation, device, passkey, priv->confirm_data);
+
+	g_object_unref(device);
+
+	return TRUE;
+}
+
+static gboolean bluetooth_agent_request_authorization(BluetoothAgent *agent,
+					const char *path, GDBusMethodInvocation *invocation)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	GDBusProxy *device;
+
+	if (priv->authorize_func == NULL)
+		return FALSE;
+
+	device = get_device_from_path(path);
+	if (device == NULL)
+		return FALSE;
+
+	priv->authorize_func(invocation, device, priv->authorize_data);
+
+	g_object_unref(device);
+
+	return TRUE;
+}
+
+static gboolean bluetooth_agent_authorize_service(BluetoothAgent *agent,
+					const char *path, const char *uuid,
+						GDBusMethodInvocation *invocation)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	GDBusProxy *device;
+
+	if (priv->authorize_service_func == NULL)
+		return FALSE;
+
+	device = get_device_from_path(path);
+	if (device == NULL)
+		return FALSE;
+
+	priv->authorize_service_func(invocation, device, uuid,
+					    priv->authorize_service_data);
+
+	g_object_unref(device);
+
+	return TRUE;
+}
+
+static gboolean bluetooth_agent_cancel(BluetoothAgent *agent,
+						GDBusMethodInvocation *invocation)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	if (priv->cancel_func == NULL)
+		return FALSE;
+
+	return priv->cancel_func(invocation, priv->cancel_data);
+}
+
+static void
+name_appeared_cb (GDBusConnection *connection,
+		  const gchar     *name,
+		  const gchar     *name_owner,
+		  BluetoothAgent  *agent)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	g_free (priv->busname);
+	priv->busname = g_strdup (name_owner);
+}
+
+static void
+name_vanished_cb (GDBusConnection *connection,
+		  const gchar     *name,
+		  BluetoothAgent  *agent)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	g_free (priv->busname);
+	priv->busname = NULL;
+}
+
+static void bluetooth_agent_init(BluetoothAgent *agent)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->introspection_data = g_dbus_node_info_new_for_xml (introspection_xml, NULL);
+	g_assert (priv->introspection_data);
+	priv->conn = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, NULL);
+	priv->watch_id = g_bus_watch_name_on_connection (priv->conn,
+							 BLUEZ_SERVICE,
+							 G_BUS_NAME_WATCHER_FLAGS_NONE,
+							 (GBusNameAppearedCallback) name_appeared_cb,
+							 (GBusNameVanishedCallback) name_vanished_cb,
+							 agent,
+							 NULL);
+}
+
+static void bluetooth_agent_finalize(GObject *agent)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	bluetooth_agent_unregister (BLUETOOTH_AGENT (agent));
+
+	g_bus_unwatch_name (priv->watch_id);
+	g_free (priv->busname);
+	g_dbus_node_info_unref (priv->introspection_data);
+	g_object_unref (priv->conn);
+
+	G_OBJECT_CLASS(bluetooth_agent_parent_class)->finalize(agent);
+}
+
+static void bluetooth_agent_class_init(BluetoothAgentClass *klass)
+{
+	GObjectClass *object_class = (GObjectClass *) klass;
+
+	g_type_class_add_private(klass, sizeof(BluetoothAgentPrivate));
+
+	object_class->finalize = bluetooth_agent_finalize;
+}
+
+BluetoothAgent *
+bluetooth_agent_new (void)
+{
+	return BLUETOOTH_AGENT (g_object_new (BLUETOOTH_TYPE_AGENT, NULL));
+}
+
+static void
+handle_method_call (GDBusConnection       *connection,
+		    const gchar           *sender,
+		    const gchar           *object_path,
+		    const gchar           *interface_name,
+		    const gchar           *method_name,
+		    GVariant              *parameters,
+		    GDBusMethodInvocation *invocation,
+		    gpointer               user_data)
+{
+	BluetoothAgent *agent = (BluetoothAgent *) user_data;
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	if (g_str_equal (sender, priv->busname) == FALSE) {
+		GError *error = NULL;
+		error = g_error_new (AGENT_ERROR, AGENT_ERROR_REJECT,
+				     "Permission Denied");
+		g_dbus_method_invocation_take_error(invocation, error);
+		return;
+	}
+
+	if (g_strcmp0 (method_name, "Release") == 0) {
+		g_dbus_method_invocation_return_value (invocation, NULL);
+	} else if (g_strcmp0 (method_name, "RequestPinCode") == 0) {
+		char *path;
+		g_variant_get (parameters, "(o)", &path);
+		bluetooth_agent_request_pincode (agent, path, invocation);
+		g_free (path);
+	} else if (g_strcmp0 (method_name, "RequestPasskey") == 0) {
+		char *path;
+		g_variant_get (parameters, "(o)", &path);
+		bluetooth_agent_request_passkey (agent, path, invocation);
+		g_free (path);
+	} else if (g_strcmp0 (method_name, "DisplayPasskey") == 0) {
+		char *path;
+		guint32 passkey;
+		guint8 entered;
+
+		g_variant_get (parameters, "(ouy)", &path, &passkey, &entered);
+		bluetooth_agent_display_passkey (agent, path, passkey, entered, invocation);
+		g_free (path);
+	} else if (g_strcmp0 (method_name, "DisplayPinCode") == 0) {
+		char *path;
+		char *pincode;
+
+		g_variant_get (parameters, "(os)", &path, &pincode);
+		bluetooth_agent_display_pincode (agent, path, pincode, invocation);
+		g_free (path);
+	} else if (g_strcmp0 (method_name, "RequestConfirmation") == 0) {
+		char *path;
+		guint32 passkey;
+
+		g_variant_get (parameters, "(ou)", &path, &passkey);
+		bluetooth_agent_request_confirmation (agent, path, passkey, invocation);
+		g_free (path);
+	} else if (g_strcmp0 (method_name, "RequestAuthorization") == 0) {
+		char *path;
+
+		g_variant_get (parameters, "(o)", &path);
+		bluetooth_agent_request_authorization (agent, path, invocation);
+		g_free (path);
+	} else if (g_strcmp0 (method_name, "AuthorizeService") == 0) {
+		char *path, *uuid;
+		g_variant_get (parameters, "(os)", &path, &uuid);
+		bluetooth_agent_authorize_service (agent, path, uuid, invocation);
+		g_free (path);
+		g_free (uuid);
+	} else if (g_strcmp0 (method_name, "Cancel") == 0) {
+		bluetooth_agent_cancel (agent, invocation);
+	}
+}
+
+static const GDBusInterfaceVTable interface_vtable =
+{
+	handle_method_call,
+	NULL, /* GetProperty */
+	NULL, /* SetProperty */
+};
+
+gboolean bluetooth_agent_setup(BluetoothAgent *agent, const char *path)
+{
+	BluetoothAgentPrivate *priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+	GError *error = NULL;
+
+	if (priv->path != NULL) {
+		g_warning ("Agent already setup on '%s'", priv->path);
+		return FALSE;
+	}
+
+	priv->path = g_strdup(path);
+
+	priv->reg_id = g_dbus_connection_register_object (priv->conn,
+						      priv->path,
+						      priv->introspection_data->interfaces[0],
+						      &interface_vtable,
+						      agent,
+						      NULL,
+						      &error);
+	if (priv->reg_id == 0) {
+		g_warning ("Failed to register object: %s", error->message);
+		g_error_free (error);
+	}
+
+	return TRUE;
+}
+
+gboolean bluetooth_agent_register(BluetoothAgent *agent)
+{
+	BluetoothAgentPrivate *priv;
+	GError *error = NULL;
+	gboolean ret;
+
+	g_return_val_if_fail (BLUETOOTH_IS_AGENT (agent), FALSE);
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE (agent);
+
+	priv->agent_manager = agent_manager1_proxy_new_for_bus_sync(G_BUS_TYPE_SYSTEM,
+                     G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+                     BLUEZ_SERVICE, "/org/bluez", NULL, NULL);
+
+	priv->reg_id = g_dbus_connection_register_object (priv->conn,
+						      BLUEZ_AGENT_PATH,
+						      priv->introspection_data->interfaces[0],
+						      &interface_vtable,
+						      agent,
+						      NULL,
+						      &error);
+	if (priv->reg_id == 0) {
+		g_warning ("Failed to register object: %s", error->message);
+		g_error_free (error);
+		error = NULL;
+		return FALSE;
+	}
+
+	ret = agent_manager1_call_register_agent_sync (priv->agent_manager,
+						       BLUEZ_AGENT_PATH,
+						       "DisplayYesNo",
+						       NULL, &error);
+	if (ret == FALSE) {
+		g_printerr ("Agent registration failed: %s\n", error->message);
+		g_error_free (error);
+		return FALSE;
+	}
+
+	ret = agent_manager1_call_request_default_agent_sync (priv->agent_manager,
+							      BLUEZ_AGENT_PATH,
+							      NULL, &error);
+	if (ret == FALSE) {
+		g_printerr ("Agent registration failed: %s\n", error->message);
+		g_error_free (error);
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+gboolean bluetooth_agent_unregister(BluetoothAgent *agent)
+{
+	BluetoothAgentPrivate *priv;
+	GError *error = NULL;
+
+	g_return_val_if_fail (BLUETOOTH_IS_AGENT (agent), FALSE);
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	if (priv->agent_manager == NULL)
+		return FALSE;
+
+	if (agent_manager1_call_unregister_agent_sync (priv->agent_manager,
+						       BLUEZ_AGENT_PATH,
+						       NULL, &error) == FALSE) {
+		/* Ignore errors if the adapter is gone */
+		if (g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD) == FALSE) {
+			g_printerr ("Agent unregistration failed: %s '%s'\n",
+				    error->message,
+				    g_quark_to_string (error->domain));
+		}
+		g_error_free(error);
+	}
+
+	g_object_unref(priv->agent_manager);
+	priv->agent_manager = NULL;
+
+	g_free(priv->path);
+	priv->path = NULL;
+
+	g_free(priv->busname);
+	priv->busname = NULL;
+
+	if (priv->reg_id > 0) {
+		g_dbus_connection_unregister_object (priv->conn, priv->reg_id);
+		priv->reg_id = 0;
+	}
+
+	return TRUE;
+}
+
+void bluetooth_agent_set_pincode_func(BluetoothAgent *agent,
+				BluetoothAgentPasskeyFunc func, gpointer data)
+{
+	BluetoothAgentPrivate *priv;
+
+	g_return_if_fail (BLUETOOTH_IS_AGENT (agent));
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->pincode_func = func;
+	priv->pincode_data = data;
+}
+
+void bluetooth_agent_set_passkey_func(BluetoothAgent *agent,
+				BluetoothAgentPasskeyFunc func, gpointer data)
+{
+	BluetoothAgentPrivate *priv;
+
+	g_return_if_fail (BLUETOOTH_IS_AGENT (agent));
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->passkey_func = func;
+	priv->passkey_data = data;
+}
+
+void bluetooth_agent_set_display_func(BluetoothAgent *agent,
+				BluetoothAgentDisplayFunc func, gpointer data)
+{
+	BluetoothAgentPrivate *priv;
+
+	g_return_if_fail (BLUETOOTH_IS_AGENT (agent));
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->display_func = func;
+	priv->display_data = data;
+}
+
+void bluetooth_agent_set_display_pincode_func(BluetoothAgent *agent,
+				BluetoothAgentDisplayPinCodeFunc func, gpointer data)
+{
+	BluetoothAgentPrivate *priv;
+
+	g_return_if_fail (BLUETOOTH_IS_AGENT (agent));
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->display_pincode_func = func;
+	priv->display_pincode_data = data;
+}
+
+void bluetooth_agent_set_confirm_func(BluetoothAgent *agent,
+				BluetoothAgentConfirmFunc func, gpointer data)
+{
+	BluetoothAgentPrivate *priv;
+
+	g_return_if_fail (BLUETOOTH_IS_AGENT (agent));
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->confirm_func = func;
+	priv->confirm_data = data;
+}
+
+void bluetooth_agent_set_authorize_func(BluetoothAgent *agent,
+				BluetoothAgentAuthorizeFunc func, gpointer data)
+{
+	BluetoothAgentPrivate *priv;
+
+	g_return_if_fail (BLUETOOTH_IS_AGENT (agent));
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->authorize_func = func;
+	priv->authorize_data = data;
+}
+
+void bluetooth_agent_set_authorize_service_func(BluetoothAgent *agent,
+				BluetoothAgentAuthorizeServiceFunc func, gpointer data)
+{
+	BluetoothAgentPrivate *priv;
+
+	g_return_if_fail (BLUETOOTH_IS_AGENT (agent));
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->authorize_service_func = func;
+	priv->authorize_service_data = data;
+}
+
+void bluetooth_agent_set_cancel_func(BluetoothAgent *agent,
+				BluetoothAgentCancelFunc func, gpointer data)
+{
+	BluetoothAgentPrivate *priv;
+
+	g_return_if_fail (BLUETOOTH_IS_AGENT (agent));
+
+	priv = BLUETOOTH_AGENT_GET_PRIVATE(agent);
+
+	priv->cancel_func = func;
+	priv->cancel_data = data;
+}
+
+GQuark bluetooth_agent_error_quark(void)
+{
+	static GQuark quark = 0;
+	if (!quark)
+		quark = g_quark_from_static_string("agent");
+
+	return quark;
+}
+
+#define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC }
+
+GType bluetooth_agent_error_get_type(void)
+{
+	static GType etype = 0;
+	if (etype == 0) {
+		static const GEnumValue values[] = {
+			ENUM_ENTRY(AGENT_ERROR_REJECT, "Rejected"),
+			{ 0, 0, 0 }
+		};
+
+		etype = g_enum_register_static("agent", values);
+	}
+
+	return etype;
+}
+

=== added file 'panels/bluetooth/gnome-bluetooth/lib/bluetooth-agent.h'
--- panels/bluetooth/gnome-bluetooth/lib/bluetooth-agent.h	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/gnome-bluetooth/lib/bluetooth-agent.h	2015-08-12 15:47:27 +0000
@@ -0,0 +1,127 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2005-2008  Marcel Holtmann <[e-mail]>
+ *
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef __BLUETOOTH_AGENT_H
+#define __BLUETOOTH_AGENT_H
+
+#include <glib-object.h>
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+
+#define BLUETOOTH_TYPE_AGENT (bluetooth_agent_get_type())
+#define BLUETOOTH_AGENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+					BLUETOOTH_TYPE_AGENT, BluetoothAgent))
+#define BLUETOOTH_AGENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), \
+					BLUETOOTH_TYPE_AGENT, BluetoothAgentClass))
+#define BLUETOOTH_IS_AGENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+							BLUETOOTH_TYPE_AGENT))
+#define BLUETOOTH_IS_AGENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), \
+							BLUETOOTH_TYPE_AGENT))
+#define BLUETOOTH_GET_AGENT_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), \
+					BLUETOOTH_TYPE_AGENT, BluetoothAgentClass))
+
+typedef struct _BluetoothAgent BluetoothAgent;
+typedef struct _BluetoothAgentClass BluetoothAgentClass;
+
+struct _BluetoothAgent {
+	GObject parent;
+};
+
+struct _BluetoothAgentClass {
+	GObjectClass parent_class;
+};
+
+GType bluetooth_agent_get_type(void);
+
+BluetoothAgent *bluetooth_agent_new(void);
+
+gboolean bluetooth_agent_setup(BluetoothAgent *agent, const char *path);
+
+gboolean bluetooth_agent_register(BluetoothAgent *agent);
+gboolean bluetooth_agent_unregister(BluetoothAgent *agent);
+
+typedef void (*BluetoothAgentPasskeyFunc) (GDBusMethodInvocation *invocation,
+					   GDBusProxy            *device,
+					   gpointer               data);
+typedef void (*BluetoothAgentDisplayFunc) (GDBusMethodInvocation *invocation,
+					   GDBusProxy            *device,
+					   guint                  passkey,
+					   guint                  entered,
+					   gpointer               data);
+typedef void (*BluetoothAgentDisplayPinCodeFunc) (GDBusMethodInvocation *invocation,
+						  GDBusProxy            *device,
+						  const char            *pincode,
+						  gpointer               data);
+typedef void (*BluetoothAgentConfirmFunc) (GDBusMethodInvocation *invocation,
+					   GDBusProxy            *device,
+					   guint                  passkey,
+					   gpointer               data);
+typedef void (*BluetoothAgentAuthorizeFunc) (GDBusMethodInvocation *invocation,
+					     GDBusProxy            *device,
+					     gpointer               data);
+typedef void (*BluetoothAgentAuthorizeServiceFunc) (GDBusMethodInvocation *invocation,
+						    GDBusProxy            *device,
+						    const char            *uuid,
+						    gpointer               data);
+typedef gboolean (*BluetoothAgentCancelFunc) (GDBusMethodInvocation *invocation,
+					      gpointer               data);
+
+void bluetooth_agent_set_pincode_func (BluetoothAgent            *agent,
+				       BluetoothAgentPasskeyFunc  func,
+				       gpointer                   data);
+void bluetooth_agent_set_passkey_func (BluetoothAgent            *agent,
+				       BluetoothAgentPasskeyFunc  func,
+				       gpointer                   data);
+void bluetooth_agent_set_display_func (BluetoothAgent            *agent,
+				       BluetoothAgentDisplayFunc  func,
+				       gpointer                   data);
+void bluetooth_agent_set_display_pincode_func (BluetoothAgent                   *agent,
+					       BluetoothAgentDisplayPinCodeFunc  func,
+					       gpointer                          data);
+void bluetooth_agent_set_confirm_func (BluetoothAgent            *agent,
+				       BluetoothAgentConfirmFunc  func,
+				       gpointer                   data);
+void bluetooth_agent_set_authorize_func (BluetoothAgent              *agent,
+					 BluetoothAgentAuthorizeFunc  func,
+					 gpointer                     data);
+void bluetooth_agent_set_authorize_service_func (BluetoothAgent                     *agent,
+						 BluetoothAgentAuthorizeServiceFunc  func,
+						 gpointer                            data);
+void bluetooth_agent_set_cancel_func (BluetoothAgent           *agent,
+				      BluetoothAgentCancelFunc  func,
+				      gpointer                  data);
+
+#define AGENT_ERROR (bluetooth_agent_error_quark())
+#define AGENT_ERROR_TYPE (bluetooth_agent_error_get_type())
+
+typedef enum {
+	AGENT_ERROR_REJECT
+} AgentError;
+
+GType  bluetooth_agent_error_get_type (void);
+GQuark bluetooth_agent_error_quark    (void);
+
+G_END_DECLS
+
+#endif /* __BLUETOOTH_AGENT_H */

=== added file 'panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-button.c'
--- panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-button.c	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-button.c	2015-08-12 15:47:27 +0000
@@ -0,0 +1,419 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * (C) Copyright 2007-2009 Bastien Nocera <[e-mail]>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * SECTION:bluetooth-chooser-button
+ * @short_description: a Bluetooth chooser button
+ * @stability: Stable
+ * @include: bluetooth-chooser-button.h
+ *
+ * A button used to select Bluetooth devices which will pop-up a
+ * #BluetoothChooser widget inside a dialogue when clicked.
+ **/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "bluetooth-chooser-button.h"
+#include "bluetooth-client.h"
+#include "bluetooth-chooser.h"
+#include "bluetooth-utils.h"
+
+struct _BluetoothChooserButton {
+	GtkButton          parent;
+
+	BluetoothClient   *client;
+	GtkWidget         *image;
+	GtkWidget         *dialog;
+	GtkWidget         *chooser;
+	char              *bdaddr;
+	guint              is_available : 1;
+	guint              has_selection : 1;
+};
+
+enum {
+	PROP_0,
+	PROP_DEVICE,
+	PROP_IS_AVAILABLE,
+};
+
+enum {
+	CHOOSER_CREATED,
+	LAST_SIGNAL
+};
+
+static int signals[LAST_SIGNAL] = { 0 };
+
+static void	bluetooth_chooser_button_class_init	(BluetoothChooserButtonClass * klass);
+static void	bluetooth_chooser_button_init		(BluetoothChooserButton      * button);
+
+static GtkButtonClass *parent_class;
+
+G_DEFINE_TYPE(BluetoothChooserButton, bluetooth_chooser_button, GTK_TYPE_BUTTON);
+
+#define DEFAULT_STR N_("Click to select device...")
+
+static void
+set_btdevname (BluetoothChooserButton *button, const char *bdaddr, const char *name, const char *icon)
+{
+	char *found_name, *found_icon;
+
+	found_name = NULL;
+	found_icon = NULL;
+
+	if (bdaddr != NULL && (name == NULL || icon == NULL)) {
+		GtkTreeModel *model;
+		GtkTreeIter iter;
+		gboolean cont = FALSE;
+
+		model = bluetooth_client_get_device_model (button->client);
+		if (model != NULL) {
+			cont = gtk_tree_model_iter_children (GTK_TREE_MODEL(model),
+							     &iter, NULL);
+		}
+
+		while (cont == TRUE) {
+			char *value;
+
+			gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
+					   BLUETOOTH_COLUMN_ADDRESS, &value, -1);
+			if (g_ascii_strcasecmp(bdaddr, value) == 0) {
+				gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
+						   BLUETOOTH_COLUMN_ALIAS, &found_name,
+						   BLUETOOTH_COLUMN_ICON, &found_icon,
+						   -1);
+				g_free (value);
+				break;
+			}
+			g_free (value);
+			cont = gtk_tree_model_iter_next (GTK_TREE_MODEL(model), &iter);
+		}
+
+		if (model != NULL)
+			g_object_unref (model);
+
+		if (found_name == NULL) {
+			found_name = g_strdup (bdaddr);
+			g_strdelimit (found_name, ":", '-');
+		}
+		if (found_icon == NULL)
+			found_icon = g_strdup ("bluetooth");
+	}
+
+	if (bdaddr != NULL) {
+		/* Update the name */
+		if (name == NULL)
+			gtk_button_set_label (GTK_BUTTON (button), found_name);
+		else
+			gtk_button_set_label (GTK_BUTTON (button), name);
+		/* And the icon */
+		if (icon == NULL)
+			gtk_image_set_from_icon_name (GTK_IMAGE (button->image), found_icon, GTK_ICON_SIZE_MENU);
+		else
+			gtk_image_set_from_icon_name (GTK_IMAGE (button->image), icon, GTK_ICON_SIZE_MENU);
+
+		/* And our copy of the address, and notify if it's actually changed */
+		if (button->bdaddr == NULL || strcmp (bdaddr, button->bdaddr) != 0) {
+			g_free (button->bdaddr);
+			button->bdaddr = g_strdup (bdaddr);
+			g_object_notify (G_OBJECT (button), "device");
+		}
+	} else {
+		gtk_button_set_label (GTK_BUTTON (button), _(DEFAULT_STR));
+		if (button->bdaddr != NULL) {
+			g_free (button->bdaddr);
+			button->bdaddr = NULL;
+			gtk_image_clear (GTK_IMAGE (button->image));
+			g_object_notify (G_OBJECT (button), "device");
+		}
+	}
+
+	g_free (found_name);
+	g_free (found_icon);
+}
+
+static void select_device_changed(BluetoothChooser *self, gchar *address, gpointer data)
+{
+	BluetoothChooserButton *button = BLUETOOTH_CHOOSER_BUTTON (data);
+
+	button->has_selection = (address != NULL);
+	gtk_dialog_set_response_sensitive(GTK_DIALOG (button->dialog), GTK_RESPONSE_ACCEPT,
+					  button->has_selection && button->is_available);
+}
+
+static void
+dialog_response_cb (GtkDialog *dialog, int response_id, gpointer data)
+{
+	BluetoothChooserButton *button = BLUETOOTH_CHOOSER_BUTTON (data);
+	char *bdaddr, *icon, *name;
+
+	if (response_id == GTK_RESPONSE_ACCEPT) {
+		BluetoothChooser *chooser = BLUETOOTH_CHOOSER (button->chooser);
+		bdaddr = bluetooth_chooser_get_selected_device (chooser);
+		name = bluetooth_chooser_get_selected_device_name (chooser);
+		icon = bluetooth_chooser_get_selected_device_icon (chooser);
+	}
+
+	gtk_widget_destroy (GTK_WIDGET (dialog));
+	button->dialog = NULL;
+
+	if (response_id != GTK_RESPONSE_ACCEPT)
+		return;
+
+	set_btdevname (button, bdaddr, name, icon);
+	g_free (bdaddr);
+	g_free (name);
+	g_free (icon);
+}
+
+static void
+bluetooth_chooser_button_clicked (GtkButton *widget)
+{
+	BluetoothChooserButton *button = BLUETOOTH_CHOOSER_BUTTON (widget);
+	GtkWidget *parent;
+
+	if (button->dialog != NULL) {
+		gtk_window_present (GTK_WINDOW (button->dialog));
+		return;
+	}
+
+	parent = gtk_widget_get_toplevel (GTK_WIDGET (button));
+	//FIXME title
+	button->dialog = gtk_dialog_new_with_buttons("", GTK_WINDOW (parent),
+						     GTK_DIALOG_MODAL,
+						     "_Cancel", GTK_RESPONSE_REJECT,
+						     "_OK", GTK_RESPONSE_ACCEPT, NULL);
+	g_signal_connect (button->dialog, "response",
+			  G_CALLBACK (dialog_response_cb), button);
+	gtk_dialog_set_response_sensitive (GTK_DIALOG(button->dialog),
+					   GTK_RESPONSE_ACCEPT, FALSE);
+	gtk_window_set_default_size (GTK_WINDOW(button->dialog), 480, 400);
+
+	gtk_container_set_border_width (GTK_CONTAINER (button->dialog), 5);
+	gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (button->dialog))), 2);
+
+	/* Create the button->chooser */
+	button->chooser = bluetooth_chooser_new ();
+	g_signal_connect(button->chooser, "selected-device-changed",
+			 G_CALLBACK(select_device_changed), button);
+	g_signal_emit (G_OBJECT (button),
+		       signals[CHOOSER_CREATED],
+		       0, button->chooser);
+	g_object_set (G_OBJECT (button->chooser), "device-selected", button->bdaddr, NULL);
+	gtk_container_set_border_width (GTK_CONTAINER(button->chooser), 5);
+	gtk_widget_show (button->chooser);
+	gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (button->dialog))), button->chooser,
+			    TRUE, TRUE, 0);
+
+	gtk_widget_show (button->dialog);
+}
+
+static void
+default_adapter_changed (GObject *object, GParamSpec *pspec, gpointer data)
+{
+	BluetoothChooserButton *button = BLUETOOTH_CHOOSER_BUTTON (data);
+	char *adapter;
+	gboolean powered;
+
+	g_object_get (G_OBJECT (button->client),
+		      "default-adapter", &adapter,
+		      "default-adapter-powered", &powered,
+		      NULL);
+	if (adapter != NULL)
+		button->is_available = powered;
+	else
+		button->is_available = FALSE;
+
+	if (adapter != NULL && button->bdaddr != NULL)
+		set_btdevname (button, button->bdaddr, NULL, NULL);
+	g_free (adapter);
+
+	if (button->dialog != NULL)
+		gtk_dialog_set_response_sensitive (GTK_DIALOG (button->dialog), GTK_RESPONSE_ACCEPT,
+						   button->has_selection && button->is_available);
+
+	g_object_notify (G_OBJECT (button), "is-available");
+}
+
+static void
+bluetooth_chooser_button_finalize (GObject *object)
+{
+	BluetoothChooserButton *button = BLUETOOTH_CHOOSER_BUTTON (object);
+
+	if (button->client != NULL) {
+		g_object_unref (button->client);
+		button->client = NULL;
+	}
+	if (button->dialog != NULL) {
+		gtk_widget_destroy (button->dialog);
+		button->dialog = NULL;
+		button->chooser = NULL;
+	}
+
+	G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+bluetooth_chooser_button_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
+{
+	BluetoothChooserButton *button;
+
+	g_return_if_fail (BLUETOOTH_IS_CHOOSER_BUTTON (object));
+	button = BLUETOOTH_CHOOSER_BUTTON (object);
+
+	switch (property_id) {
+	case PROP_DEVICE: {
+		const char *str = g_value_get_string (value);
+		g_return_if_fail (str == NULL || bluetooth_verify_address (str));
+		set_btdevname (button, str, NULL, NULL);
+		break;
+		}
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+	}
+}
+
+static void
+bluetooth_chooser_button_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
+{
+	BluetoothChooserButton *button;
+
+	g_return_if_fail (BLUETOOTH_IS_CHOOSER_BUTTON (object));
+	button = BLUETOOTH_CHOOSER_BUTTON (object);
+
+	switch (property_id) {
+	case PROP_DEVICE:
+		g_value_set_string (value, button->bdaddr);
+		break;
+	case PROP_IS_AVAILABLE:
+		g_value_set_boolean (value, button->is_available);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+	}
+}
+
+static void
+bluetooth_chooser_button_class_init (BluetoothChooserButtonClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+	GtkButtonClass *button_class = GTK_BUTTON_CLASS (klass);
+
+	parent_class = g_type_class_peek_parent (klass);
+
+	object_class->finalize = bluetooth_chooser_button_finalize;
+	object_class->set_property = bluetooth_chooser_button_set_property;
+	object_class->get_property = bluetooth_chooser_button_get_property;
+
+	button_class->clicked = bluetooth_chooser_button_clicked;
+
+	/**
+	 * BluetoothChooserButton::chooser-created:
+	 * @self: a #BluetoothChooserButton widget
+	 * @chooser: a #BluetoothChooser widget
+	 *
+	 * The signal is sent when a popup dialogue is created for the user to select
+	 * a device. This signal allows you to change the configuration and filtering
+	 * of the tree from its defaults.
+	 **/
+	signals[CHOOSER_CREATED] =
+		g_signal_new ("chooser-created",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (BluetoothChooserButtonClass, chooser_created),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__OBJECT,
+			      G_TYPE_NONE, 1, G_TYPE_OBJECT);
+
+	/**
+	 * BluetoothChooserButton:device:
+	 *
+	 * The Bluetooth address of the selected device or %NULL.
+	 **/
+	g_object_class_install_property (object_class, PROP_DEVICE,
+					 g_param_spec_string ("device", "Device", "The Bluetooth address of the selected device.",
+							      NULL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+	/**
+	 * BluetoothChooserButton:is-available:
+	 *
+	 * %TRUE if there is a powered Bluetooth adapter available.
+	 *
+	 * See also: bluetooth_chooser_button_available()
+	 **/
+	g_object_class_install_property (object_class, PROP_IS_AVAILABLE,
+					 g_param_spec_boolean ("is-available", "Bluetooth is available", "Whether Bluetooth is available.",
+							       TRUE, G_PARAM_READABLE));
+}
+
+static void
+bluetooth_chooser_button_init (BluetoothChooserButton *button)
+{
+	gtk_button_set_label (GTK_BUTTON (button), _(DEFAULT_STR));
+
+	button->image = gtk_image_new ();
+	gtk_button_set_image (GTK_BUTTON (button), button->image);
+
+	button->bdaddr = NULL;
+	button->dialog = NULL;
+
+	button->client = bluetooth_client_new ();
+	g_signal_connect (G_OBJECT (button->client), "notify::default-adapter",
+			  G_CALLBACK (default_adapter_changed), button);
+	g_signal_connect (G_OBJECT (button->client), "notify::default-adapter-powered",
+			  G_CALLBACK (default_adapter_changed), button);
+
+	/* And set the default value already */
+	default_adapter_changed (NULL, NULL, button);
+}
+
+/**
+ * bluetooth_chooser_button_new:
+ *
+ * Returns a new #BluetoothChooserButton widget.
+ *
+ * Return value: a #BluetoothChooserButton widget.
+ **/
+GtkWidget *
+bluetooth_chooser_button_new (void)
+{
+	return g_object_new (BLUETOOTH_TYPE_CHOOSER_BUTTON,
+			     NULL);
+}
+
+/**
+ * bluetooth_chooser_button_available:
+ * @button: a #BluetoothChooserButton
+ *
+ * Returns whether there is a powered Bluetooth adapter.
+ *
+ * Return value: %TRUE if there is a powered Bluetooth adapter available, and the button should be sensitive.
+ **/
+gboolean
+bluetooth_chooser_button_available (BluetoothChooserButton *button)
+{
+	g_return_val_if_fail (BLUETOOTH_IS_CHOOSER_BUTTON (button), FALSE);
+
+	return button->is_available;
+}
+

=== added file 'panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-button.h'
--- panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-button.h	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-button.h	2015-08-12 15:47:27 +0000
@@ -0,0 +1,55 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * (C) Copyright 2007 Bastien Nocera <[e-mail]>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __BLUETOOTH_CHOOSER_BUTTON_H__
+#define __BLUETOOTH_CHOOSER_BUTTON_H__
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define BLUETOOTH_TYPE_CHOOSER_BUTTON     (bluetooth_chooser_button_get_type ())
+#define BLUETOOTH_CHOOSER_BUTTON(obj)     (G_TYPE_CHECK_INSTANCE_CAST ((obj), BLUETOOTH_TYPE_CHOOSER_BUTTON, BluetoothChooserButton))
+#define BLUETOOTH_IS_CHOOSER_BUTTON(obj)  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BLUETOOTH_TYPE_CHOOSER_BUTTON))
+
+/**
+ * BluetoothChooserButton:
+ *
+ * The <structname>BluetoothChooserButton</structname> struct contains
+ * only private fields and should not be directly accessed.
+ */
+typedef struct _BluetoothChooserButton BluetoothChooserButton;
+
+typedef struct _BluetoothChooserButtonClass BluetoothChooserButtonClass;
+
+struct _BluetoothChooserButtonClass {
+  GtkButtonClass parent_class;
+
+  void (*chooser_created) (BluetoothChooserButton *self, GtkWidget *chooser);
+};
+
+GType		bluetooth_chooser_button_get_type	(void);
+
+GtkWidget *	bluetooth_chooser_button_new		(void);
+gboolean	bluetooth_chooser_button_available	(BluetoothChooserButton *button);
+
+G_END_DECLS
+
+#endif /* __BLUETOOTH_CHOOSER_BUTTON_H__ */

=== added file 'panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-combo.c'
--- panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-combo.c	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-combo.c	2015-08-12 15:47:27 +0000
@@ -0,0 +1,365 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * (C) Copyright 2007-2009 Bastien Nocera <[e-mail]>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * SECTION:bluetooth-chooser-combo
+ * @short_description: a Bluetooth chooser combo button
+ * @stability: Stable
+ * @include: bluetooth-chooser-combo.h
+ *
+ * A combo box used to select Bluetooth devices.
+ **/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <glib/gi18n.h>
+#include <gtk/gtk.h>
+
+#include "bluetooth-chooser-combo.h"
+#include "bluetooth-client.h"
+#include "bluetooth-chooser.h"
+#include "bluetooth-chooser-private.h"
+#include "bluetooth-utils.h"
+
+struct _BluetoothChooserComboPrivate {
+	GtkWidget         *chooser;
+	GtkWidget         *drop_box;
+	GtkWidget         *drop;
+	GtkTreeModel      *model;
+	guint              model_notify_id;
+	GtkTreeSelection  *selection;
+
+	char              *bdaddr;
+};
+
+enum {
+	PROP_0,
+	PROP_CHOOSER,
+	PROP_DEVICE,
+};
+
+enum {
+	CHOOSER_CREATED,
+	LAST_SIGNAL
+};
+
+static int signals[LAST_SIGNAL] = { 0 };
+
+static void	bluetooth_chooser_combo_class_init	(BluetoothChooserComboClass * klass);
+static void	bluetooth_chooser_combo_init		(BluetoothChooserCombo      * combo);
+
+static GtkBoxClass *parent_class;
+
+G_DEFINE_TYPE(BluetoothChooserCombo, bluetooth_chooser_combo, GTK_TYPE_BOX);
+
+#define BLUETOOTH_CHOOSER_COMBO_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
+									BLUETOOTH_TYPE_CHOOSER_COMBO, BluetoothChooserComboPrivate))
+
+static void
+bluetooth_chooser_combo_set_device (BluetoothChooserCombo *combo,
+				    const char *bdaddr)
+{
+	if (bdaddr == NULL || combo->priv->model == NULL) {
+		g_free (combo->priv->bdaddr);
+		gtk_widget_set_sensitive (combo->priv->drop_box, FALSE);
+	} else {
+		GtkTreeIter iter;
+		gboolean cont = FALSE;
+
+		gtk_widget_set_sensitive (combo->priv->drop_box, TRUE);
+
+		g_free (combo->priv->bdaddr);
+		if (g_strcmp0 (BLUETOOTH_CHOOSER_COMBO_FIRST_DEVICE, bdaddr) != 0)
+			combo->priv->bdaddr = g_strdup (bdaddr);
+		else
+			combo->priv->bdaddr = NULL;
+
+		cont = gtk_tree_model_iter_children (combo->priv->model, &iter, NULL);
+		while (cont == TRUE) {
+			char *value;
+
+			gtk_tree_model_get (GTK_TREE_MODEL (combo->priv->model), &iter,
+					    BLUETOOTH_COLUMN_ADDRESS, &value, -1);
+
+			if (combo->priv->bdaddr == NULL) {
+				gtk_tree_selection_select_iter (combo->priv->selection, &iter);
+				combo->priv->bdaddr = value;
+				break;
+			}
+
+			if (g_ascii_strcasecmp(bdaddr, value) == 0) {
+				gtk_tree_selection_select_iter (combo->priv->selection, &iter);
+				g_free (value);
+				break;
+			}
+			g_free (value);
+			cont = gtk_tree_model_iter_next (GTK_TREE_MODEL (combo->priv->model), &iter);
+		}
+	}
+	g_object_notify (G_OBJECT (combo), "device");
+}
+
+static void
+bluetooth_chooser_combo_dispose (GObject *object)
+{
+	BluetoothChooserCombo *combo = BLUETOOTH_CHOOSER_COMBO (object);
+
+	if (combo->priv->model_notify_id != 0) {
+		GtkWidget *treeview;
+
+		treeview = bluetooth_chooser_get_treeview (BLUETOOTH_CHOOSER (combo->priv->chooser));
+		g_signal_handler_disconnect (treeview, combo->priv->model_notify_id);
+		combo->priv->model_notify_id = 0;
+	}
+	if (combo->priv->model != NULL) {
+		g_object_unref (combo->priv->model);
+		combo->priv->model = NULL;
+	}
+	if (combo->priv->chooser != NULL) {
+		g_object_unref (combo->priv->chooser);
+		combo->priv->chooser = NULL;
+	}
+
+	G_OBJECT_CLASS (parent_class)->dispose (object);
+}
+
+static void
+bluetooth_chooser_combo_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
+{
+	BluetoothChooserCombo *combo;
+
+	g_return_if_fail (BLUETOOTH_IS_CHOOSER_COMBO (object));
+	combo = BLUETOOTH_CHOOSER_COMBO (object);
+
+	switch (property_id) {
+	case PROP_DEVICE:
+		g_return_if_fail (bluetooth_verify_address (g_value_get_string (value)) || g_value_get_string (value) == NULL);
+		bluetooth_chooser_combo_set_device (combo, g_value_get_string (value));
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+	}
+}
+
+static void
+bluetooth_chooser_combo_get_property (GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
+{
+	BluetoothChooserCombo *combo;
+
+	g_return_if_fail (BLUETOOTH_IS_CHOOSER_COMBO (object));
+	combo = BLUETOOTH_CHOOSER_COMBO (object);
+
+	switch (property_id) {
+	case PROP_CHOOSER:
+		g_value_set_object (value, combo->priv->chooser);
+		break;
+	case PROP_DEVICE:
+		g_value_set_string (value, combo->priv->bdaddr);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+	}
+}
+
+static void
+bluetooth_chooser_combo_class_init (BluetoothChooserComboClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	parent_class = g_type_class_peek_parent (klass);
+
+	object_class->dispose = bluetooth_chooser_combo_dispose;
+	object_class->set_property = bluetooth_chooser_combo_set_property;
+	object_class->get_property = bluetooth_chooser_combo_get_property;
+
+	g_type_class_add_private(klass, sizeof(BluetoothChooserComboPrivate));
+
+	/**
+	 * BluetoothChooserCombo::chooser-created:
+	 * @self: a #BluetoothChooserCombo widget
+	 * @chooser: a #BluetoothChooser widget
+	 *
+	 * The signal is sent when a popup dialogue is created for the user to select
+	 * a device. This signal allows you to change the configuration and filtering
+	 * of the tree from its defaults.
+	 **/
+	signals[CHOOSER_CREATED] =
+		g_signal_new ("chooser-created",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (BluetoothChooserComboClass, chooser_created),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__OBJECT,
+			      G_TYPE_NONE, 1, G_TYPE_OBJECT);
+
+	/**
+	 * BluetoothChooserCombo:chooser:
+	 *
+	 * The #BluetoothChooser used in the widget
+	 **/
+	g_object_class_install_property (object_class, PROP_CHOOSER,
+					 g_param_spec_object ("chooser", "Chooser", "The #BluetoothChooser used in the widget",
+							      BLUETOOTH_TYPE_CHOOSER, G_PARAM_READABLE));
+	/**
+	 * BluetoothChooserCombo:device:
+	 *
+	 * The Bluetooth address of the selected device or %NULL
+	 **/
+	g_object_class_install_property (object_class, PROP_DEVICE,
+					 g_param_spec_string ("device", "Device", "The Bluetooth address of the selected device.",
+							      NULL, G_PARAM_READWRITE));
+}
+
+static void
+treeview_model_notify_cb (GObject    *gobject,
+			  GParamSpec *pspec,
+			  gpointer    user_data)
+{
+	BluetoothChooserCombo *combo = BLUETOOTH_CHOOSER_COMBO (user_data);
+	GtkTreeModel *model;
+
+	g_object_get (gobject, "model", &model, NULL);
+	gtk_combo_box_set_model (GTK_COMBO_BOX (combo->priv->drop), model);
+	if (combo->priv->model != NULL) {
+		g_object_unref (combo->priv->model);
+		combo->priv->model = NULL;
+	}
+	combo->priv->model = model;
+}
+
+static void
+treeview_selection_changed_cb (GtkTreeSelection *treeselection,
+			       gpointer          user_data)
+{
+	BluetoothChooserCombo *combo = BLUETOOTH_CHOOSER_COMBO (user_data);
+	GtkTreeIter iter;
+	char *value = NULL;
+
+	if (gtk_tree_selection_get_selected (combo->priv->selection, NULL, &iter)) {
+		gtk_combo_box_set_active_iter (GTK_COMBO_BOX (combo->priv->drop), &iter);
+		if (combo->priv->model != NULL)
+			gtk_tree_model_get (GTK_TREE_MODEL (combo->priv->model), &iter,
+					    BLUETOOTH_COLUMN_ADDRESS, &value, -1);
+	} else {
+		if (combo->priv->model != NULL)
+			gtk_combo_box_set_active (GTK_COMBO_BOX (combo->priv->drop), -1);
+	}
+
+	if (g_strcmp0 (combo->priv->bdaddr, value) != 0) {
+		g_free (combo->priv->bdaddr);
+		combo->priv->bdaddr = value;
+		g_object_notify (G_OBJECT (combo), "device");
+	} else {
+		g_free (value);
+	}
+}
+
+static void
+drop_changed_cb (GtkComboBox *widget,
+		 gpointer     user_data)
+{
+	BluetoothChooserCombo *combo = BLUETOOTH_CHOOSER_COMBO (user_data);
+	GtkTreeIter iter;
+	char *value = NULL;
+
+	if (gtk_combo_box_get_active_iter (widget, &iter)) {
+		gtk_tree_selection_select_iter (combo->priv->selection, &iter);
+		if (combo->priv->model != NULL)
+			gtk_tree_model_get (GTK_TREE_MODEL (combo->priv->model), &iter,
+					    BLUETOOTH_COLUMN_ADDRESS, &value, -1);
+	} else {
+		if (combo->priv->model != NULL)
+			gtk_tree_selection_unselect_all (combo->priv->selection);
+	}
+
+	if (g_strcmp0 (combo->priv->bdaddr, value) != 0) {
+		g_free (combo->priv->bdaddr);
+		combo->priv->bdaddr = value;
+		g_object_notify (G_OBJECT (combo), "device");
+	} else {
+		g_free (value);
+	}
+}
+
+static void
+bluetooth_chooser_combo_init (BluetoothChooserCombo *combo)
+{
+	GtkWidget *treeview;
+	GtkCellRenderer *renderer;
+
+	combo->priv = BLUETOOTH_CHOOSER_COMBO_GET_PRIVATE (combo);
+
+	combo->priv->drop_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+	gtk_box_set_homogeneous (GTK_BOX (combo->priv->drop_box), TRUE);
+	gtk_box_pack_start (GTK_BOX (combo), combo->priv->drop_box,
+			    TRUE, FALSE, 0);
+	/* Setup the combo itself */
+	combo->priv->drop = gtk_combo_box_new ();
+	gtk_box_pack_start (GTK_BOX (combo->priv->drop_box), combo->priv->drop,
+			    TRUE, TRUE, 0);
+	renderer = gtk_cell_renderer_pixbuf_new ();
+	gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo->priv->drop),
+				    renderer,
+				    FALSE);
+	gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo->priv->drop),
+					renderer,
+					"icon-name", BLUETOOTH_COLUMN_ICON,
+					NULL);
+	renderer = gtk_cell_renderer_text_new ();
+	gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo->priv->drop),
+				    renderer,
+				    TRUE);
+	gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo->priv->drop),
+					renderer,
+					"text", BLUETOOTH_COLUMN_ALIAS,
+					NULL);
+
+	combo->priv->chooser = bluetooth_chooser_new ();
+
+	treeview = bluetooth_chooser_get_treeview (BLUETOOTH_CHOOSER (combo->priv->chooser));
+	combo->priv->model_notify_id = g_signal_connect (G_OBJECT (treeview), "notify::model",
+						   G_CALLBACK (treeview_model_notify_cb), combo);
+	treeview_model_notify_cb (G_OBJECT (treeview), NULL, combo);
+	gtk_combo_box_set_active (GTK_COMBO_BOX (combo->priv->drop), 0);
+
+	combo->priv->selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
+	g_signal_connect (G_OBJECT (combo->priv->selection), "changed",
+			  G_CALLBACK (treeview_selection_changed_cb), combo);
+	g_signal_connect (G_OBJECT (combo->priv->drop), "changed",
+			  G_CALLBACK (drop_changed_cb), combo);
+
+	gtk_widget_show_all (GTK_WIDGET (combo));
+}
+
+/**
+ * bluetooth_chooser_combo_new:
+ *
+ * Returns a new #BluetoothChooserCombo widget.
+ *
+ * Return value: a #BluetoothChooserCombo widget.
+ **/
+GtkWidget *
+bluetooth_chooser_combo_new (void)
+{
+	return g_object_new (BLUETOOTH_TYPE_CHOOSER_COMBO, NULL);
+}
+

=== added file 'panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-combo.h'
--- panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-combo.h	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-combo.h	2015-08-12 15:47:27 +0000
@@ -0,0 +1,69 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * (C) Copyright 2007 Bastien Nocera <[e-mail]>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __BLUETOOTH_CHOOSER_COMBO_H__
+#define __BLUETOOTH_CHOOSER_COMBO_H__
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define BLUETOOTH_TYPE_CHOOSER_COMBO     (bluetooth_chooser_combo_get_type ())
+#define BLUETOOTH_CHOOSER_COMBO(obj)     (G_TYPE_CHECK_INSTANCE_CAST ((obj), BLUETOOTH_TYPE_CHOOSER_COMBO, BluetoothChooserCombo))
+#define BLUETOOTH_IS_CHOOSER_COMBO(obj)  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BLUETOOTH_TYPE_CHOOSER_COMBO))
+#define BLUETOOTH_IS_CHOOSER_COMBO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), \
+									 BLUETOOTH_TYPE_CHOOSER_COMBO))
+#define BLUETOOTH_GET_CHOOSER_COMBO_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), \
+				BLUETOOTH_TYPE_CHOOSER_COMBO, BluetoothChooserComboClass))
+
+/**
+* BLUETOOTH_CHOOSER_COMBO_FIRST_DEVICE:
+*
+* A convenience value used to select the first device regardless of its address.
+**/
+#define BLUETOOTH_CHOOSER_COMBO_FIRST_DEVICE "00:00:00:00:00:00"
+
+typedef struct _BluetoothChooserComboPrivate BluetoothChooserComboPrivate;
+typedef struct _BluetoothChooserComboClass BluetoothChooserComboClass;
+
+/**
+ * BluetoothChooserCombo:
+ *
+ * The <structname>BluetoothChooserCombo</structname> struct contains
+ * only private fields and should not be directly accessed.
+ */
+typedef struct _BluetoothChooserCombo {
+	GtkBox            parent;
+	BluetoothChooserComboPrivate *priv;
+} BluetoothChooserCombo;
+
+struct _BluetoothChooserComboClass {
+  GtkBoxClass parent_class;
+
+  void (*chooser_created) (BluetoothChooserCombo *self, GtkWidget *chooser);
+};
+
+GType		bluetooth_chooser_combo_get_type	(void);
+
+GtkWidget *	bluetooth_chooser_combo_new		(void);
+
+G_END_DECLS
+
+#endif /* __BLUETOOTH_CHOOSER_COMBO_H__ */

=== added file 'panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-private.h'
--- panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-private.h	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser-private.h	2015-08-12 15:47:27 +0000
@@ -0,0 +1,39 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2009  Bastien Nocera <[e-mail]>
+ *
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef __BLUETOOTH_CHOOSER_PRIVATE_H
+#define __BLUETOOTH_CHOOSER_PRIVATE_H
+
+#include <glib-object.h>
+#include <gtk/gtk.h>
+#include <bluetooth-enums.h>
+
+G_BEGIN_DECLS
+
+GtkTreeModel *bluetooth_chooser_get_model (BluetoothChooser *self);
+GtkWidget *bluetooth_chooser_get_treeview (BluetoothChooser *self);
+gboolean bluetooth_chooser_remove_selected_device (BluetoothChooser *self);
+
+G_END_DECLS
+
+#endif /* __BLUETOOTH_CHOOSER_PRIVATE_H */

=== added file 'panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser.c'
--- panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser.c	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser.c	2015-08-12 15:47:27 +0000
@@ -0,0 +1,1173 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2005-2008  Marcel Holtmann <[e-mail]>
+ *  Copyright (C) 2006-2007  Bastien Nocera <[e-mail]>
+ *
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+/**
+ * SECTION:bluetooth-chooser
+ * @short_description: a Bluetooth chooser widget
+ * @stability: Stable
+ * @include: bluetooth-chooser.h
+ *
+ * A tree-like widget used to select Bluetooth devices.
+ **/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <gtk/gtk.h>
+
+#include <glib/gi18n-lib.h>
+
+#include "bluetooth-client.h"
+#include "bluetooth-client-private.h"
+#include "bluetooth-utils.h"
+#include "bluetooth-chooser.h"
+#include "bluetooth-chooser-private.h"
+#include "gnome-bluetooth-enum-types.h"
+#include "bluetooth-filter-widget.h"
+
+enum {
+	SELECTED_DEVICE_CHANGED,
+	SELECTED_DEVICE_ACTIVATED,
+	LAST_SIGNAL
+};
+
+static int selection_table_signals[LAST_SIGNAL] = { 0 };
+
+#define BLUETOOTH_CHOOSER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
+									BLUETOOTH_TYPE_CHOOSER, BluetoothChooserPrivate))
+
+typedef struct _BluetoothChooserPrivate BluetoothChooserPrivate;
+
+struct _BluetoothChooserPrivate {
+	BluetoothClient *client;
+	GtkTreeSelection *selection;
+	GtkTreeModel *model, *filter, *adapter_model;
+
+	gulong default_adapter_changed_id;
+
+	/* Widgets/UI bits that can be shown or hidden */
+	GtkCellRenderer *bonded_cell;
+	GtkCellRenderer *connected_cell;
+	GtkWidget *treeview, *scrolled_window;
+	GtkWidget *search_hbox, *search_label, *spinner;
+	GtkWidget *filters_vbox;
+
+	/* Current filter */
+	int device_type_filter;
+	GtkTreeModel *device_type_filter_model;
+	int device_category_filter;
+	char *device_service_filter;
+
+	guint show_paired : 1;
+	guint show_connected : 1;
+	guint show_searching : 1;
+	guint show_device_type : 1;
+	guint show_device_category : 1;
+	guint disco_rq : 1;
+	guint internal_filter : 1;
+};
+
+G_DEFINE_TYPE(BluetoothChooser, bluetooth_chooser, GTK_TYPE_BOX)
+
+enum {
+	DEVICE_TYPE_FILTER_COL_NAME = 0,
+	DEVICE_TYPE_FILTER_COL_MASK,
+	DEVICE_TYPE_FILTER_NUM_COLS
+};
+
+enum {
+	TREEVIEW_COLUMN_DEVICE = 0,
+	TREEVIEW_COLUMN_TYPE = 1
+};
+
+static void
+bonded_to_icon (GtkTreeViewColumn *column, GtkCellRenderer *cell,
+	      GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
+{
+	gboolean bonded;
+
+	gtk_tree_model_get (model, iter, BLUETOOTH_COLUMN_PAIRED, &bonded, -1);
+
+	g_object_set (cell, "icon-name", bonded ? "bluetooth-paired" : NULL, NULL);
+}
+
+static void
+connected_to_icon (GtkTreeViewColumn *column, GtkCellRenderer *cell,
+	      GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
+{
+	gboolean connected;
+
+	gtk_tree_model_get (model, iter, BLUETOOTH_COLUMN_CONNECTED, &connected, -1);
+
+	g_object_set (cell, "icon-name", connected ? "gtk-connected" : NULL, NULL);
+}
+
+static void
+type_to_text (GtkTreeViewColumn *column, GtkCellRenderer *cell,
+	      GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
+{
+	guint type;
+
+	gtk_tree_model_get (model, iter, BLUETOOTH_COLUMN_TYPE, &type, -1);
+
+	g_object_set (cell, "text", (type == 0) ? _("Unknown") : bluetooth_type_to_string (type), NULL);
+}
+
+static void
+alias_to_label (GtkTreeViewColumn *column, GtkCellRenderer *cell,
+		GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
+{
+	char *alias, *escaped, *label;
+	gboolean connected;
+
+	gtk_tree_model_get (model, iter,
+			    BLUETOOTH_COLUMN_ALIAS, &alias,
+			    BLUETOOTH_COLUMN_CONNECTED, &connected,
+			    -1);
+
+	if (connected == FALSE) {
+		g_object_set (cell, "text", alias, NULL);
+	} else {
+		escaped = g_markup_escape_text (alias, -1);
+		label = g_strdup_printf ("<b>%s</b>", escaped);
+		g_free (escaped);
+
+		g_object_set (cell, "markup", label, NULL);
+		g_free (label);
+	}
+	g_free (alias);
+}
+
+static void
+set_search_label (BluetoothChooser *self, gboolean state)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+
+	if (priv->show_searching == FALSE) {
+		/* Just making sure */
+		gtk_spinner_stop (GTK_SPINNER (priv->spinner));
+		return;
+	}
+	if (state == FALSE) {
+		gtk_spinner_stop (GTK_SPINNER (priv->spinner));
+		gtk_widget_hide (priv->spinner);
+		gtk_label_set_text (GTK_LABEL (priv->search_label), _("No adapters available"));
+	} else {
+		gtk_widget_show (priv->spinner);
+		gtk_spinner_start (GTK_SPINNER (priv->spinner));
+		gtk_label_set_text (GTK_LABEL (priv->search_label), _("Searching for devices..."));
+	}
+}
+
+/**
+ * bluetooth_chooser_start_discovery:
+ * @self: a #BluetoothChooser widget.
+ *
+ * Starts a discovery on the default Bluetooth adapter. Note that this will
+ * only work if the Search label is visible, as otherwise the user has no
+ * visual feedback that the process is on-going.
+ *
+ * See also: #BluetoothChooser:show-searching
+ **/
+void
+bluetooth_chooser_start_discovery (BluetoothChooser *self)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+
+	g_return_if_fail (priv->show_searching);
+
+	g_object_set (G_OBJECT (priv->client), "default-adapter-discovering", TRUE, NULL);
+	set_search_label (self, TRUE);
+	priv->disco_rq = TRUE;
+}
+
+/**
+ * bluetooth_chooser_stop_discovery:
+ * @self: a #BluetoothChooser widget.
+ *
+ * Stops a discovery started with #bluetooth_chooser_start_discovery.
+ **/
+void
+bluetooth_chooser_stop_discovery (BluetoothChooser *self)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+
+	g_return_if_fail (priv->show_searching);
+
+	priv->disco_rq = FALSE;
+	g_object_set (G_OBJECT (priv->client), "default-adapter-discovering", FALSE, NULL);
+}
+
+static char *
+bluetooth_chooser_get_selected_device_data (BluetoothChooser *self, guint column)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+	GtkTreeIter iter;
+	gchar *str;
+	gboolean selected;
+
+	selected = gtk_tree_selection_get_selected (priv->selection, NULL, &iter);
+	if (selected == FALSE)
+		return NULL;
+
+	gtk_tree_model_get (priv->filter, &iter, column, &str, -1);
+	return str;
+}
+
+/**
+ * bluetooth_chooser_get_selected_device:
+ * @self: a #BluetoothChooser widget.
+ *
+ * Returns the Bluetooth address for the currently selected device.
+ *
+ * Return value: the Bluetooth address for the currently selected device, or %NULL.
+ **/
+gchar *
+bluetooth_chooser_get_selected_device (BluetoothChooser *self)
+{
+	return bluetooth_chooser_get_selected_device_data (self, BLUETOOTH_COLUMN_ADDRESS);
+}
+
+/**
+ * bluetooth_chooser_get_selected_device_name:
+ * @self: a #BluetoothChooser widget.
+ *
+ * Returns the name for the currently selected device.
+ *
+ * Return value: the name for the currently selected device, or %NULL.
+ **/
+gchar *
+bluetooth_chooser_get_selected_device_name (BluetoothChooser *self)
+{
+	return bluetooth_chooser_get_selected_device_data (self, BLUETOOTH_COLUMN_NAME);
+}
+
+/**
+ * bluetooth_chooser_get_selected_device_icon:
+ * @self: a #BluetoothChooser widget.
+ *
+ * Returns the icon name to use to represent the currently selected device.
+ *
+ * Return value: the icon name to use to represent the currently selected device, or %NULL.
+ **/
+gchar *
+bluetooth_chooser_get_selected_device_icon (BluetoothChooser *self)
+{
+	return bluetooth_chooser_get_selected_device_data (self, BLUETOOTH_COLUMN_ICON);
+}
+
+/**
+ * bluetooth_chooser_get_selected_device_type:
+ * @self: a #BluetoothChooser widget.
+ *
+ * Returns the #BluetoothType of the device selected.
+ *
+ * Return value: the #BluetoothType of the device selected, or '0' if unknown.
+ **/
+BluetoothType
+bluetooth_chooser_get_selected_device_type (BluetoothChooser *self)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+	GtkTreeIter iter;
+	guint type;
+	gboolean selected;
+
+	selected = gtk_tree_selection_get_selected (priv->selection, NULL, &iter);
+	if (selected == FALSE)
+		return 0;
+
+	gtk_tree_model_get (priv->filter, &iter, BLUETOOTH_COLUMN_TYPE, &type, -1);
+	return type;
+}
+
+/**
+ * bluetooth_chooser_get_selected_device_is_connected:
+ * @self: a #BluetoothChooser widget.
+ *
+ * Returns whether the selected device is connected to this computer.
+ *
+ * Return value: whether the selected device is connected to this computer,
+ * will always be %FALSE if no devices are selected.
+ **/
+gboolean
+bluetooth_chooser_get_selected_device_is_connected (BluetoothChooser *self)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+	GtkTreeIter iter;
+	gboolean selected, connected;
+
+	selected = gtk_tree_selection_get_selected (priv->selection, NULL, &iter);
+	if (selected == FALSE)
+		return 0;
+
+	gtk_tree_model_get (priv->filter, &iter, BLUETOOTH_COLUMN_CONNECTED, &connected, -1);
+	return connected;
+}
+
+/**
+ * bluetooth_chooser_get_selected_device_info:
+ * @self: A #BluetoothChooser widget.
+ * @field: The identifier for the field to get data for.
+ * @value: An empty #GValue to set.
+ *
+ * Returns whether the @value has been set.
+ *
+ * Return value: %TRUE if the @value has been set.
+ **/
+gboolean
+bluetooth_chooser_get_selected_device_info (BluetoothChooser *self,
+					    const char *field,
+					    GValue *value)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+	GEnumClass *eclass;
+	GEnumValue *ev;
+	GtkTreeIter iter;
+
+	g_return_val_if_fail (field != NULL, FALSE);
+
+	if (gtk_tree_selection_get_selected (priv->selection, NULL, &iter) == FALSE)
+		return FALSE;
+
+	eclass = g_type_class_ref (BLUETOOTH_TYPE_COLUMN);
+	ev = g_enum_get_value_by_nick (eclass, field);
+	if (ev == NULL) {
+		g_warning ("Unknown field '%s'", field);
+		g_type_class_unref (eclass);
+		return FALSE;
+	}
+
+	gtk_tree_model_get_value (priv->filter, &iter, ev->value, value);
+
+	g_type_class_unref (eclass);
+
+	return TRUE;
+}
+
+/**
+ * bluetooth_chooser_dump_selected_device:
+ * @self: A #BluetoothChooser widget.
+ *
+ * Prints all the known attributes for the currently selected device
+ * on the standard output. Useful for debugging.
+ **/
+void
+bluetooth_chooser_dump_selected_device (BluetoothChooser *self)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+	GtkTreeIter iter;
+	GtkTreeModel *model;
+
+	gtk_tree_selection_get_selected (priv->selection, &model, &iter);
+
+	bluetooth_client_dump_device (model, &iter);
+}
+
+/**
+ * bluetooth_chooser_get_model:
+ * @self: A #BluetoothChooser widget.
+ *
+ * Returns the #BluetoothChooser's #GtkTreeModel.
+ *
+ * Return value: a #GtkTreeModel object.
+ **/
+GtkTreeModel *
+bluetooth_chooser_get_model (BluetoothChooser *self)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+
+	return priv->model;
+}
+
+/**
+ * bluetooth_chooser_get_treeview:
+ * @self: A #BluetoothChooser widget.
+ *
+ * Returns the #GtkTreeView object for the #BluetoothChooser.
+ *
+ * Return value: a #GtkTreeView object.
+ **/
+GtkWidget *
+bluetooth_chooser_get_treeview (BluetoothChooser *self)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+
+	return priv->treeview;
+}
+
+/**
+ * bluetooth_chooser_get_scrolled_window:
+ * @self: A #BluetoothChooser widget.
+ *
+ * Returns the #GtkScrolledWindow object for the #BluetoothChooser.
+ * This is useful to set a minimum height to the chooser using
+ * gtk_scrolled_window_set_min_content_height() or to join the
+ * chooser with a toolbar.
+ *
+ * Return value: (transfer none): a #GtkScrolledWindow object.
+ **/
+GtkWidget *
+bluetooth_chooser_get_scrolled_window (BluetoothChooser *self)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+
+	return priv->scrolled_window;
+}
+
+static void
+device_model_row_changed (GtkTreeModel *model,
+			   GtkTreePath  *path,
+			   GtkTreeIter  *iter,
+			   gpointer      data)
+{
+	BluetoothChooser *self = BLUETOOTH_CHOOSER (data);
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+	char *address;
+
+	/* Not the selection changing? */
+	if (gtk_tree_selection_path_is_selected (priv->selection, path) == FALSE)
+		return;
+
+	g_object_notify (G_OBJECT (self), "device-selected");
+	address = bluetooth_chooser_get_selected_device (self);
+	g_signal_emit (G_OBJECT (self),
+		       selection_table_signals[SELECTED_DEVICE_CHANGED],
+		       0, address);
+	g_free (address);
+}
+
+static void
+select_browse_device_callback (GtkTreeSelection *selection, gpointer user_data)
+{
+	BluetoothChooser *self = user_data;
+	char *address;
+
+	g_object_notify (G_OBJECT(self), "device-selected");
+	address = bluetooth_chooser_get_selected_device (self);
+	g_signal_emit (G_OBJECT (self),
+		       selection_table_signals[SELECTED_DEVICE_CHANGED],
+		       0, address);
+	g_free (address);
+}
+
+static void
+row_activated_cb (GtkTreeView       *tree_view,
+		  GtkTreePath       *path,
+		  GtkTreeViewColumn *column,
+		  BluetoothChooser  *self)
+{
+	char *address;
+
+	address = bluetooth_chooser_get_selected_device (self);
+	g_signal_emit (G_OBJECT (self),
+		       selection_table_signals[SELECTED_DEVICE_ACTIVATED],
+		       0, address);
+	g_free (address);
+}
+
+static gboolean
+filter_type_func (GtkTreeModel *model, GtkTreeIter *iter, BluetoothChooserPrivate *priv)
+{
+	int type;
+
+	if (priv->device_type_filter == BLUETOOTH_TYPE_ANY)
+		return TRUE;
+
+	gtk_tree_model_get (model, iter, BLUETOOTH_COLUMN_TYPE, &type, -1);
+	return (type & priv->device_type_filter);
+}
+
+static gboolean
+filter_category_func (GtkTreeModel *model, GtkTreeIter *iter, BluetoothChooserPrivate *priv)
+{
+	gboolean bonded, trusted;
+
+	if (priv->device_category_filter == BLUETOOTH_CATEGORY_ALL)
+		return TRUE;
+
+	gtk_tree_model_get (model, iter,
+			    BLUETOOTH_COLUMN_PAIRED, &bonded,
+			    BLUETOOTH_COLUMN_TRUSTED, &trusted,
+			    -1);
+
+	if (priv->device_category_filter == BLUETOOTH_CATEGORY_PAIRED)
+		return bonded;
+	if (priv->device_category_filter == BLUETOOTH_CATEGORY_TRUSTED)
+		return trusted;
+	if (priv->device_category_filter == BLUETOOTH_CATEGORY_NOT_PAIRED_OR_TRUSTED)
+		return (!bonded && !trusted);
+	if (priv->device_category_filter == BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED)
+		return (bonded || trusted);
+
+	g_assert_not_reached ();
+
+	return FALSE;
+}
+
+static gboolean
+filter_service_func (GtkTreeModel *model, GtkTreeIter *iter, BluetoothChooserPrivate *priv)
+{
+	char **services;
+	gboolean ret = FALSE;
+	guint i;
+
+	if (priv->device_service_filter == NULL)
+		return TRUE;
+
+	gtk_tree_model_get (model, iter,
+			    BLUETOOTH_COLUMN_UUIDS, &services,
+			    -1);
+	if (services == NULL) {
+		/* FIXME we need a way to discover the services here */
+		return FALSE;
+	}
+
+	for (i = 0; services[i] != NULL; i++) {
+		if (g_str_equal (priv->device_service_filter, services[i]) != FALSE) {
+			ret = TRUE;
+			break;
+		}
+	}
+
+	g_strfreev (services);
+
+	return ret;
+}
+
+static gboolean
+filter_func (GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
+{
+	BluetoothChooser *self = BLUETOOTH_CHOOSER (data);
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+
+	return filter_type_func (model, iter, priv)
+		&& filter_category_func (model, iter, priv)
+		&& filter_service_func (model, iter, priv);
+}
+
+static void
+filter_type_changed_cb (GObject *object, GParamSpec *spec, gpointer user_data)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(object);
+
+	if (priv->filter)
+		gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (priv->filter));
+}
+
+static void
+filter_category_changed_cb (GObject *object, GParamSpec *spec, gpointer user_data)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(object);
+
+	if (priv->filter)
+		gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (priv->filter));
+}
+
+static void
+adapter_model_row_changed (GtkTreeModel *model,
+			   GtkTreePath  *path,
+			   GtkTreeIter  *iter,
+			   gpointer      data)
+{
+	BluetoothChooser *self = BLUETOOTH_CHOOSER (data);
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+	gboolean discovering, is_default, powered;
+
+	/* Not an adapter changing? */
+	if (gtk_tree_path_get_depth (path) != 1)
+		return;
+
+	gtk_tree_model_get (model, iter,
+			    BLUETOOTH_COLUMN_DEFAULT, &is_default,
+			    BLUETOOTH_COLUMN_DISCOVERING, &discovering,
+			    BLUETOOTH_COLUMN_POWERED, &powered,
+			    -1);
+
+	if (is_default == FALSE)
+		return;
+	if (powered != FALSE && discovering == FALSE && priv->disco_rq != FALSE) {
+		g_object_set (G_OBJECT (priv->client), "default-adapter-discovering", TRUE, NULL);
+		set_search_label (self, TRUE);
+		return;
+	}
+	gtk_widget_set_sensitive (GTK_WIDGET (priv->treeview), powered);
+	set_search_label (self, discovering);
+}
+
+static void default_adapter_changed (GObject    *gobject,
+				     GParamSpec *arg1,
+				     gpointer    data)
+{
+	BluetoothChooser *self = BLUETOOTH_CHOOSER (data);
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+	char *adapter;
+
+	g_object_get (gobject, "default-adapter", &adapter, NULL);
+
+	if (adapter == NULL) {
+		gtk_widget_set_sensitive (GTK_WIDGET (priv->treeview), FALSE);
+		set_search_label (self, FALSE);
+		gtk_tree_view_set_model (GTK_TREE_VIEW(priv->treeview), NULL);
+	}
+
+	if (priv->model) {
+		g_object_unref (priv->model);
+		priv->model = NULL;
+	}
+
+	if (adapter == NULL)
+		return;
+
+	g_free (adapter);
+
+	priv->model = bluetooth_client_get_device_model (priv->client);
+	if (priv->model) {
+		priv->filter = gtk_tree_model_filter_new (priv->model, NULL);
+		gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->filter),
+							filter_func, self, NULL);
+		gtk_tree_view_set_model (GTK_TREE_VIEW(priv->treeview), priv->filter);
+		g_signal_connect (priv->filter, "row-changed",
+				  G_CALLBACK (device_model_row_changed), self);
+		g_object_unref (priv->filter);
+		gtk_widget_set_sensitive (GTK_WIDGET (priv->treeview), TRUE);
+
+		/* Start a discovery if it was requested before we
+		 * had an adapter available */
+		if (priv->disco_rq != FALSE) {
+			bluetooth_chooser_start_discovery (self);
+			set_search_label (self, TRUE);
+		}
+	}
+}
+
+static GtkWidget *
+create_treeview (BluetoothChooser *self)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+	GtkWidget *scrolled, *tree;
+	GtkCellRenderer *renderer;
+	GtkTreeViewColumn *column;
+
+	/* Create the scrolled window */
+	scrolled = gtk_scrolled_window_new (NULL, NULL);
+
+	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolled),
+					GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+
+	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW(scrolled),
+					     GTK_SHADOW_OUT);
+
+	/* Create the tree view */
+	tree = gtk_tree_view_new ();
+
+	gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(tree), TRUE);
+
+	gtk_tree_view_set_rules_hint (GTK_TREE_VIEW(tree), TRUE);
+
+	g_object_set (tree, "show-expanders", FALSE, NULL);
+
+	g_signal_connect (G_OBJECT (tree), "row-activated",
+			  G_CALLBACK (row_activated_cb), self);
+
+	column = gtk_tree_view_column_new ();
+
+	gtk_tree_view_column_set_title (column, _("Device"));
+	gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN(column), TRUE);
+
+	/* The type icon */
+	renderer = gtk_cell_renderer_pixbuf_new ();
+	gtk_tree_view_column_set_spacing (column, 4);
+	gtk_tree_view_column_pack_start (column, renderer, FALSE);
+	gtk_tree_view_column_set_attributes (column, renderer,
+					     "icon-name", BLUETOOTH_COLUMN_ICON, NULL);
+
+	/* The device name */
+	renderer = gtk_cell_renderer_text_new ();
+	gtk_tree_view_column_pack_start (column, renderer, TRUE);
+	g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
+	gtk_tree_view_column_set_cell_data_func (column, renderer,
+						 alias_to_label, NULL, NULL);
+
+	/* The connected icon */
+	priv->connected_cell = gtk_cell_renderer_pixbuf_new ();
+	gtk_tree_view_column_pack_start (column, priv->connected_cell, FALSE);
+
+	gtk_tree_view_column_set_cell_data_func (column, priv->connected_cell,
+						 connected_to_icon, NULL, NULL);
+	g_object_set (G_OBJECT (priv->connected_cell), "visible", priv->show_connected, NULL);
+
+	/* The bonded icon */
+	priv->bonded_cell = gtk_cell_renderer_pixbuf_new ();
+	gtk_tree_view_column_pack_end (column, priv->bonded_cell, FALSE);
+
+	gtk_tree_view_column_set_cell_data_func (column, priv->bonded_cell,
+						 bonded_to_icon, NULL, NULL);
+	g_object_set (G_OBJECT (priv->bonded_cell), "visible", priv->show_paired, NULL);
+
+	gtk_tree_view_append_column (GTK_TREE_VIEW(tree), column);
+
+	gtk_tree_view_insert_column_with_data_func (GTK_TREE_VIEW(tree), -1,
+						    _("Type"), gtk_cell_renderer_text_new(),
+						    type_to_text, NULL, NULL);
+
+	priv->selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
+
+	gtk_tree_selection_set_mode (priv->selection, GTK_SELECTION_SINGLE);
+
+	g_signal_connect (G_OBJECT(priv->selection), "changed",
+			  G_CALLBACK(select_browse_device_callback), self);
+
+	/* Set the model, and filter */
+	priv->model = bluetooth_client_get_device_model (priv->client);
+	if (priv->model) {
+		priv->filter = gtk_tree_model_filter_new (priv->model, NULL);
+		gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER (priv->filter),
+							filter_func, self, NULL);
+		gtk_tree_view_set_model (GTK_TREE_VIEW(tree), priv->filter);
+		g_signal_connect (priv->filter, "row-changed",
+				  G_CALLBACK (device_model_row_changed), self);
+		g_object_unref (priv->filter);
+	} else {
+		gtk_widget_set_sensitive (GTK_WIDGET (tree), FALSE);
+		set_search_label (self, FALSE);
+	}
+
+	gtk_container_add (GTK_CONTAINER(scrolled), tree);
+	priv->treeview = tree;
+
+	return scrolled;
+}
+
+static void
+bluetooth_chooser_init(BluetoothChooser *self)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+
+	GtkWidget *vbox;
+	GtkWidget *hbox;
+
+	gtk_widget_push_composite_child ();
+
+	g_object_set (G_OBJECT (self), "orientation", GTK_ORIENTATION_VERTICAL, NULL);
+
+	priv->client = bluetooth_client_new ();
+
+	/* Setup the widget itself */
+	gtk_box_set_spacing (GTK_BOX(self), 18);
+	gtk_container_set_border_width (GTK_CONTAINER(self), 0);
+
+	vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
+	gtk_widget_show (vbox);
+	gtk_box_pack_start (GTK_BOX (self), vbox, TRUE, TRUE, 0);
+
+	/* The treeview label */
+	priv->search_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 24);
+	gtk_widget_set_name (priv->search_hbox, "search_hbox");
+	if (priv->show_searching)
+		gtk_widget_show (priv->search_hbox);
+	gtk_box_pack_end (GTK_BOX (vbox), priv->search_hbox, FALSE, TRUE, 0);
+	gtk_widget_set_no_show_all (priv->search_hbox, TRUE);
+
+	/* Setup the adapter disco mode callback for the search button */
+	priv->adapter_model = bluetooth_client_get_adapter_model (priv->client);
+	g_signal_connect (priv->adapter_model, "row-changed",
+			  G_CALLBACK (adapter_model_row_changed), self);
+
+	/* The searching label */
+	hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+	gtk_widget_set_name (hbox, "searching label hbox");
+	priv->spinner = gtk_spinner_new ();
+	gtk_container_add (GTK_CONTAINER (hbox), priv->spinner);
+	gtk_widget_show (priv->spinner);
+	priv->search_label = gtk_label_new (_("Searching for devices..."));
+	gtk_container_add (GTK_CONTAINER (hbox), priv->search_label);
+	gtk_widget_show (priv->search_label);
+	gtk_widget_show (hbox);
+
+	if (priv->show_searching) {
+		gboolean discovering;
+
+		g_object_get (G_OBJECT (priv->client), "default-adapter-discovering", &discovering, NULL);
+		set_search_label (self, discovering);
+	}
+
+	gtk_box_pack_start (GTK_BOX (priv->search_hbox), hbox, FALSE, TRUE, 0);
+
+	/* The treeview */
+	priv->scrolled_window = create_treeview (self);
+	gtk_widget_show_all (priv->scrolled_window);
+	gtk_box_pack_start (GTK_BOX (vbox), priv->scrolled_window, TRUE, TRUE, 0);
+	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (priv->scrolled_window), GTK_SHADOW_IN);
+
+	/* The filters */
+	priv->device_type_filter_model = GTK_TREE_MODEL (gtk_list_store_new (DEVICE_TYPE_FILTER_NUM_COLS,
+						         G_TYPE_STRING, G_TYPE_INT));
+	priv->filters_vbox = bluetooth_filter_widget_new ();
+	gtk_widget_show (priv->filters_vbox);
+	gtk_box_pack_start (GTK_BOX (self), priv->filters_vbox, FALSE, TRUE, 0);
+	gtk_widget_set_no_show_all (priv->filters_vbox, TRUE);
+
+	/* if filters are not visible hide the vbox */
+	if (!priv->show_device_type && !priv->show_device_category)
+		gtk_widget_hide (priv->filters_vbox);
+
+	priv->default_adapter_changed_id = g_signal_connect (priv->client, "notify::default-adapter",
+							     G_CALLBACK (default_adapter_changed), self);
+
+	g_signal_connect(self, "notify::device-type-filter",
+			 G_CALLBACK(filter_type_changed_cb), NULL);
+	g_signal_connect(self, "notify::device-category-filter",
+			 G_CALLBACK(filter_category_changed_cb), NULL);
+
+	gtk_widget_pop_composite_child ();
+}
+
+static GObject *
+bluetooth_chooser_constructor (GType                  type,
+			       guint                  n_construct_params,
+			       GObjectConstructParam *construct_params)
+{
+	BluetoothChooser *self;
+	BluetoothChooserPrivate *priv;
+	GObject *object;
+
+	object = G_OBJECT_CLASS (bluetooth_chooser_parent_class)->constructor (type,
+									       n_construct_params,
+									       construct_params);
+	self = BLUETOOTH_CHOOSER (object);
+	priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
+
+	if (priv->internal_filter) {
+		bluetooth_filter_widget_bind_filter (BLUETOOTH_FILTER_WIDGET (priv->filters_vbox), self);
+	}
+	return object;
+}
+
+static void
+bluetooth_chooser_finalize (GObject *object)
+{
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(object);
+
+	if (priv->client) {
+		g_signal_handler_disconnect (G_OBJECT(priv->client), priv->default_adapter_changed_id);
+		priv->default_adapter_changed_id = 0;
+
+		g_object_set (G_OBJECT (priv->client), "default-adapter-discovering", FALSE, NULL);
+		g_object_unref (priv->client);
+		priv->client = NULL;
+	}
+	if (priv->adapter_model) {
+		g_object_unref (priv->adapter_model);
+		priv->adapter_model = NULL;
+	}
+	if (priv->model != NULL) {
+		g_object_unref (priv->model);
+		priv->model = NULL;
+	}
+	g_free (priv->device_service_filter);
+
+	G_OBJECT_CLASS(bluetooth_chooser_parent_class)->finalize(object);
+}
+
+enum {
+	PROP_0,
+	PROP_DEVICE_SELECTED,
+	PROP_SHOW_PAIRING,
+	PROP_SHOW_CONNECTED,
+	PROP_SHOW_SEARCHING,
+	PROP_SHOW_DEVICE_TYPE,
+	PROP_SHOW_DEVICE_TYPE_COLUMN,
+	PROP_SHOW_DEVICE_CATEGORY,
+	PROP_DEVICE_TYPE_FILTER,
+	PROP_DEVICE_CATEGORY_FILTER,
+	PROP_DEVICE_SERVICE_FILTER,
+	PROP_INTERNAL_FILTER
+};
+
+static void
+bluetooth_chooser_set_property (GObject *object, guint prop_id,
+					 const GValue *value, GParamSpec *pspec)
+{
+	BluetoothChooser *self = BLUETOOTH_CHOOSER (object);
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE (object);
+
+	switch (prop_id) {
+	case PROP_DEVICE_SELECTED: {
+		const char *address;
+		char *selected;
+		GtkTreeIter iter;
+		gboolean cont;
+
+		address = g_value_get_string (value);
+		if (address == NULL) {
+			gtk_tree_selection_unselect_all (priv->selection);
+			return;
+		}
+
+		selected = bluetooth_chooser_get_selected_device (self);
+		if (g_strcmp0 (selected, address) == 0) {
+			g_free (selected);
+			return;
+		}
+		g_free (selected);
+
+		cont = gtk_tree_model_get_iter_first (priv->filter, &iter);
+		while (cont == TRUE) {
+			char *iaddress;
+			gtk_tree_model_get (priv->filter, &iter,
+					    BLUETOOTH_COLUMN_ADDRESS, &iaddress, -1);
+			if (g_strcmp0 (iaddress, address) == 0) {
+				gtk_tree_selection_select_iter (priv->selection, &iter);
+				g_free (iaddress);
+				return;
+			}
+			g_free (iaddress);
+
+			cont = gtk_tree_model_iter_next (priv->filter, &iter);
+		}
+		break;
+	}
+	case PROP_SHOW_PAIRING:
+		priv->show_paired = g_value_get_boolean (value);
+		if (priv->bonded_cell != NULL)
+			g_object_set (G_OBJECT (priv->bonded_cell), "visible", priv->show_paired, NULL);
+		break;
+	case PROP_SHOW_CONNECTED:
+		priv->show_connected = g_value_get_boolean (value);
+		if (priv->connected_cell != NULL)
+			g_object_set (G_OBJECT (priv->connected_cell), "visible", priv->show_connected, NULL);
+		break;
+	case PROP_SHOW_SEARCHING:
+		priv->show_searching = g_value_get_boolean (value);
+		g_object_set (G_OBJECT (priv->search_hbox), "visible", priv->show_searching, NULL);
+		break;
+	case PROP_SHOW_DEVICE_TYPE:
+		priv->show_device_type = g_value_get_boolean (value);
+		if (priv->internal_filter) {
+			if (priv->show_device_type || priv->show_device_category)
+				g_object_set (G_OBJECT (priv->filters_vbox), "visible", TRUE, NULL);
+			else
+				g_object_set (G_OBJECT (priv->filters_vbox), "visible", FALSE, NULL);
+		}
+		break;
+	case PROP_SHOW_DEVICE_TYPE_COLUMN: {
+		GtkTreeViewColumn *column;
+
+		column = gtk_tree_view_get_column (GTK_TREE_VIEW (priv->treeview), TREEVIEW_COLUMN_TYPE);
+		gtk_tree_view_column_set_visible (column,
+						  g_value_get_boolean (value));
+
+		column = gtk_tree_view_get_column (GTK_TREE_VIEW (priv->treeview), TREEVIEW_COLUMN_DEVICE);
+		if (g_value_get_boolean (value))
+			gtk_tree_view_column_set_title (column, _("Device"));
+		else
+			gtk_tree_view_column_set_title (column, _("Devices"));
+		break;
+		}
+	case PROP_SHOW_DEVICE_CATEGORY:
+		priv->show_device_category = g_value_get_boolean (value);
+		if (priv->internal_filter) {
+			if (priv->show_device_type || priv->show_device_category)
+				g_object_set (G_OBJECT (priv->filters_vbox), "visible", TRUE, NULL);
+			else
+				g_object_set (G_OBJECT (priv->filters_vbox), "visible", FALSE, NULL);
+		}
+		break;
+	case PROP_DEVICE_TYPE_FILTER:
+		priv->device_type_filter = g_value_get_int (value);
+		g_object_notify (object, "device-type-filter");
+		break;
+	case PROP_DEVICE_CATEGORY_FILTER:
+		priv->device_category_filter = g_value_get_enum (value);
+		g_object_notify (object, "device-category-filter");
+		break;
+	case PROP_DEVICE_SERVICE_FILTER:
+		g_free (priv->device_service_filter);
+		priv->device_service_filter = g_value_dup_string (value);
+		if (priv->filter)
+			gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (priv->filter));
+		break;
+	case PROP_INTERNAL_FILTER:
+		priv->internal_filter = g_value_get_boolean (value);
+		g_object_set (G_OBJECT (priv->filters_vbox), "visible", priv->internal_filter, NULL);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+		break;
+	}
+}
+
+static void
+bluetooth_chooser_get_property (GObject *object, guint prop_id,
+					 GValue *value, GParamSpec *pspec)
+{
+	BluetoothChooser *self = BLUETOOTH_CHOOSER(object);
+	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(object);
+
+	switch (prop_id) {
+	case PROP_DEVICE_SELECTED:
+		g_value_take_string (value, bluetooth_chooser_get_selected_device (self));
+		break;
+	case PROP_SHOW_PAIRING:
+		g_value_set_boolean (value, priv->show_paired);
+		break;
+	case PROP_SHOW_CONNECTED:
+		g_value_set_boolean (value, priv->show_connected);
+		break;
+	case PROP_SHOW_SEARCHING:
+		g_value_set_boolean (value, priv->show_searching);
+		break;
+	case PROP_SHOW_DEVICE_TYPE:
+		g_value_set_boolean (value, priv->show_device_type);
+		break;
+	case PROP_SHOW_DEVICE_TYPE_COLUMN:
+		g_value_set_boolean (value,
+				     gtk_tree_view_column_get_visible (gtk_tree_view_get_column (GTK_TREE_VIEW (priv->treeview), TREEVIEW_COLUMN_TYPE)));
+		break;
+	case PROP_SHOW_DEVICE_CATEGORY:
+		g_value_set_boolean (value, priv->show_device_category);
+		break;
+	case PROP_DEVICE_TYPE_FILTER:
+		g_value_set_int (value, priv->device_type_filter);
+		break;
+	case PROP_DEVICE_CATEGORY_FILTER:
+		g_value_set_enum (value, priv->device_category_filter);
+		break;
+	case PROP_DEVICE_SERVICE_FILTER:
+		g_value_set_string (value, priv->device_service_filter);
+		break;
+	case PROP_INTERNAL_FILTER:
+		g_value_set_boolean (value, priv->internal_filter);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+		break;
+	}
+}
+
+static void
+bluetooth_chooser_class_init (BluetoothChooserClass *klass)
+{
+	/* Use to calculate the maximum value for the
+	 * device-type-filter value */
+	guint i;
+	int max_filter_val;
+
+	bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8");
+
+	g_type_class_add_private(klass, sizeof(BluetoothChooserPrivate));
+
+	G_OBJECT_CLASS(klass)->constructor = bluetooth_chooser_constructor;
+	G_OBJECT_CLASS(klass)->finalize = bluetooth_chooser_finalize;
+
+	G_OBJECT_CLASS(klass)->set_property = bluetooth_chooser_set_property;
+	G_OBJECT_CLASS(klass)->get_property = bluetooth_chooser_get_property;
+
+	/**
+	 * BluetoothChooser::selected-device-changed:
+	 * @chooser: a #BluetoothChooser widget which received the signal
+	 * @address: the Bluetooth address for the currently selected device, or %NULL
+	 *
+	 * The #BluetoothChooser::selected-device-changed signal is launched when the
+	 * selected device is changed, it will be %NULL if a device was unselected.
+	 **/
+	selection_table_signals[SELECTED_DEVICE_CHANGED] =
+		g_signal_new ("selected-device-changed",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (BluetoothChooserClass, selected_device_changed),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__STRING,
+			      G_TYPE_NONE, 1, G_TYPE_STRING);
+	/**
+	 * BluetoothChooser::selected-device-activated:
+	 * @chooser: a #BluetoothChooser widget which received the signal
+	 * @address: the Bluetooth address for the currently selected device, or %NULL
+	 *
+	 * The #BluetoothChooser::selected-device-activated signal is launched when a
+	 * device is double-clicked in the chooser.
+	 **/
+	selection_table_signals[SELECTED_DEVICE_ACTIVATED] =
+		g_signal_new ("selected-device-activated",
+			      G_TYPE_FROM_CLASS (klass),
+			      G_SIGNAL_RUN_LAST,
+			      G_STRUCT_OFFSET (BluetoothChooserClass, selected_device_activated),
+			      NULL, NULL,
+			      g_cclosure_marshal_VOID__STRING,
+			      G_TYPE_NONE, 1, G_TYPE_STRING);
+
+	g_object_class_install_property (G_OBJECT_CLASS(klass),
+					 PROP_DEVICE_SELECTED, g_param_spec_string ("device-selected",
+										    "device-selected", "The Bluetooth address for the currently selected device, or %NULL", NULL, G_PARAM_READABLE | G_PARAM_WRITABLE));
+	g_object_class_install_property (G_OBJECT_CLASS(klass),
+					 PROP_SHOW_PAIRING, g_param_spec_boolean ("show-pairing",
+										  "show-pairing", "Whether to show the pairing column in the tree.", FALSE, G_PARAM_READWRITE));
+	g_object_class_install_property (G_OBJECT_CLASS(klass),
+					 PROP_SHOW_CONNECTED, g_param_spec_boolean ("show-connected",
+										    "show-connected", "Whether to show the connected column in the tree.", FALSE, G_PARAM_READWRITE));
+	g_object_class_install_property (G_OBJECT_CLASS(klass),
+					 PROP_SHOW_SEARCHING, g_param_spec_boolean ("show-searching",
+										    "show-searching",
+										    "Whether to show the Searching label , this is necessary if you want to programmatically start a discovery, using bluetooth_chooser_start_discovery()",
+										    FALSE, G_PARAM_READWRITE));
+	g_object_class_install_property (G_OBJECT_CLASS(klass),
+					 PROP_SHOW_DEVICE_TYPE, g_param_spec_boolean ("show-device-type",
+										      "show-device-type", "Whether to show the device type filter", TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+	g_object_class_install_property (G_OBJECT_CLASS(klass),
+					 PROP_SHOW_DEVICE_TYPE_COLUMN, g_param_spec_boolean ("show-device-type-column",
+											     "show-device-type-column", "Whether to show the device type column", TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+	g_object_class_install_property (G_OBJECT_CLASS(klass),
+					 PROP_SHOW_DEVICE_CATEGORY, g_param_spec_boolean ("show-device-category",
+											  "show-device-category", "Whether to show the device category filter", TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+	for (i = 0, max_filter_val = 0 ; i < _BLUETOOTH_TYPE_NUM_TYPES; i++)
+		max_filter_val += 1 << i;
+	g_object_class_install_property (G_OBJECT_CLASS(klass),
+					 PROP_DEVICE_TYPE_FILTER, g_param_spec_int ("device-type-filter",
+										    "device-type-filter", "A bitmask of #BluetoothType to show", BLUETOOTH_TYPE_ANY, max_filter_val, 1, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+	g_object_class_install_property (G_OBJECT_CLASS(klass),
+					 PROP_DEVICE_CATEGORY_FILTER, g_param_spec_enum ("device-category-filter",
+											 "device-category-filter", "The #BluetoothCategory to show", BLUETOOTH_TYPE_CATEGORY, BLUETOOTH_CATEGORY_ALL, G_PARAM_READWRITE | G_PARAM_CONSTRUCT));
+	g_object_class_install_property (G_OBJECT_CLASS(klass),
+					 PROP_DEVICE_SERVICE_FILTER, g_param_spec_string ("device-service-filter",
+											  "device-service-filter", "A string representing the service to filter for", NULL, G_PARAM_WRITABLE));
+	g_object_class_install_property (G_OBJECT_CLASS(klass),
+					 PROP_INTERNAL_FILTER, g_param_spec_boolean ("has-internal-device-filter",
+											  "has-internal-device-filter", "Whether the #BluetoothChooser should be constructed with a visible #BluetoothFilterWidget", TRUE, G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
+}
+
+/**
+ * bluetooth_chooser_new:
+ *
+ * Returns a new #BluetoothChooser widget.
+ *
+ * Return value: A #BluetoothChooser widget
+ **/
+GtkWidget *
+bluetooth_chooser_new (void)
+{
+	return g_object_new(BLUETOOTH_TYPE_CHOOSER, NULL);
+}
+

=== added file 'panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser.h'
--- panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser.h	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/gnome-bluetooth/lib/bluetooth-chooser.h	2015-08-12 15:47:27 +0000
@@ -0,0 +1,86 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2005-2008  Marcel Holtmann <[e-mail]>
+ *  Copyright (C) 2006-2007  Bastien Nocera <[e-mail]>
+ *
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef __BLUETOOTH_CHOOSER_H
+#define __BLUETOOTH_CHOOSER_H
+
+#include <gtk/gtk.h>
+#include <bluetooth-enums.h>
+
+G_BEGIN_DECLS
+
+#define BLUETOOTH_TYPE_CHOOSER (bluetooth_chooser_get_type())
+#define BLUETOOTH_CHOOSER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+				BLUETOOTH_TYPE_CHOOSER, BluetoothChooser))
+#define BLUETOOTH_CHOOSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), \
+				BLUETOOTH_TYPE_CHOOSER, BluetoothChooserClass))
+#define BLUETOOTH_IS_CHOOSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+						BLUETOOTH_TYPE_CHOOSER))
+#define BLUETOOTH_IS_CHOOSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), \
+						BLUETOOTH_TYPE_CHOOSER))
+#define BLUETOOTH_GET_CHOOSER_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), \
+				BLUETOOTH_TYPE_CHOOSER, BluetoothChooserClass))
+
+/**
+ * BluetoothChooser:
+ *
+ * The <structname>BluetoothChooser</structname> struct contains
+ * only private fields and should not be directly accessed.
+ */
+typedef struct _BluetoothChooser BluetoothChooser;
+typedef struct _BluetoothChooserClass BluetoothChooserClass;
+
+struct _BluetoothChooser {
+	GtkBox parent;
+};
+
+struct _BluetoothChooserClass {
+	GtkBoxClass parent_class;
+
+	void (*selected_device_changed) (BluetoothChooser *chooser, const char *address);
+	void (*selected_device_activated) (BluetoothChooser *chooser, const char *address);
+};
+
+GType bluetooth_chooser_get_type (void);
+
+GtkWidget *bluetooth_chooser_new (void);
+
+char *bluetooth_chooser_get_selected_device (BluetoothChooser *self);
+gboolean bluetooth_chooser_get_selected_device_info (BluetoothChooser *self,
+						     const char *field,
+						     GValue *value);
+char *bluetooth_chooser_get_selected_device_name (BluetoothChooser *self);
+char * bluetooth_chooser_get_selected_device_icon (BluetoothChooser *self);
+BluetoothType bluetooth_chooser_get_selected_device_type (BluetoothChooser *self);
+gboolean bluetooth_chooser_get_selected_device_is_connected (BluetoothChooser *self);
+void bluetooth_chooser_dump_selected_device (BluetoothChooser *self);
+
+GtkWidget *bluetooth_chooser_get_scrolled_window (BluetoothChooser *self);
+
+void bluetooth_chooser_start_discovery (BluetoothChooser *self);
+void bluetooth_chooser_stop_discovery (BluetoothChooser *self);
+
+G_END_DECLS
+
+#endif /* __BLUETOOTH_CHOOSER_H */

=== added file 'panels/bluetooth/gnome-bluetooth/lib/bluetooth-client-private.h'
--- panels/bluetooth/gnome-bluetooth/lib/bluetooth-client-private.h	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/gnome-bluetooth/lib/bluetooth-client-private.h	2015-08-12 15:47:27 +0000
@@ -0,0 +1,61 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2005-2008  Marcel Holtmann <[e-mail]>
+ *
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef __BLUETOOTH_CLIENT_PRIVATE_H
+#define __BLUETOOTH_CLIENT_PRIVATE_H
+
+#include <glib-object.h>
+#include <gtk/gtk.h>
+#include <bluetooth-enums.h>
+
+G_BEGIN_DECLS
+
+typedef void (*BluetoothClientSetupFunc) (BluetoothClient *client,
+					  const GError    *error,
+					  const char      *device_path);
+
+void bluetooth_client_setup_device (BluetoothClient          *client,
+				    const char               *path,
+				    gboolean                  pair,
+				    GCancellable             *cancellable,
+				    GAsyncReadyCallback       callback,
+				    gpointer                  user_data);
+gboolean bluetooth_client_setup_device_finish (BluetoothClient  *client,
+					       GAsyncResult     *res,
+					       char            **path,
+					       GError          **error);
+
+gboolean bluetooth_client_set_trusted(BluetoothClient *client,
+					const char *device, gboolean trusted);
+
+GDBusProxy *bluetooth_client_get_device (BluetoothClient *client,
+					 const char      *path);
+
+void bluetooth_client_dump_device (GtkTreeModel *model,
+				   GtkTreeIter *iter);
+
+gboolean bluetooth_client_get_connectable(const char **uuids);
+
+G_END_DECLS
+
+#endif /* __BLUETOOTH_CLIENT_PRIVATE_H */

=== added file 'panels/bluetooth/gnome-bluetooth/lib/bluetooth-client.c'
--- panels/bluetooth/gnome-bluetooth/lib/bluetooth-client.c	1970-01-01 00:00:00 +0000
+++ panels/bluetooth/gnome-bluetooth/lib/bluetooth-client.c	2015-08-12 15:47:27 +0000
@@ -0,0 +1,1757 @@
+/*
+ *
+ *  BlueZ - Bluetooth protocol stack for Linux
+ *
+ *  Copyright (C) 2005-2008  Marcel Holtmann <[e-mail]>
+ *  Copyright (C) 2010       Giovanni Campagna <[e-mail]>
+ *  Copyright (C) 2013       Intel Corporation.
+ *
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License as published by the Free Software Foundation; either
+ *  version 2.1 of the License, or (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+/**
+ * SECTION:bluetooth-client
+ * @short_description: Bluetooth client object
+ * @stability: Stable
+ * @include: bluetooth-client.h
+ *
+ * The #BluetoothClient object is used to query the state of Bluetooth
+ * devices and adapters.
+ **/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+#include <glib/gi18n-lib.h>
+#include <gtk/gtk.h>
+
+#include "bluetooth-client.h"
+#include "bluetooth-client-private.h"
+#include "bluetooth-client-glue.h"
+#include "bluetooth-fdo-glue.h"
+#include "bluetooth-utils.h"
+#include "gnome-bluetooth-enum-types.h"
+
+#define BLUEZ_SERVICE			"org.bluez"
+#define BLUEZ_MANAGER_PATH		"/"
+#define BLUEZ_ADAPTER_INTERFACE		"org.bluez.Adapter1"
+#define BLUEZ_DEVICE_INTERFACE		"org.bluez.Device1"
+#define FDO_PROPERTIES_INTERFACE	"org.freedesktop.DBus.Properties"
+
+#define BLUETOOTH_CLIENT_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
+				BLUETOOTH_TYPE_CLIENT, BluetoothClientPrivate))
+
+typedef struct _BluetoothClientPrivate BluetoothClientPrivate;
+
+struct _BluetoothClientPrivate {
+	guint owner_change_id;
+	ObjectManager *manager;
+	GtkTreeStore *store;
+	GtkTreeRowReference *default_adapter;
+};
+
+enum {
+	PROP_0,
+	PROP_DEFAULT_ADAPTER,
+	PROP_DEFAULT_ADAPTER_POWERED,
+	PROP_DEFAULT_ADAPTER_DISCOVERABLE,
+	PROP_DEFAULT_ADAPTER_NAME,
+	PROP_DEFAULT_ADAPTER_DISCOVERING
+};
+
+enum {
+	DEVICE_REMOVED,
+	LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+static const char *connectable_uuids[] = {
+	"HSP",
+	"AudioSource",
+	"AudioSink",
+	"A/V_RemoteControlTarget",
+	"A/V_RemoteControl",
+	"Headset_-_AG",
+	"Handsfree",
+	"HandsfreeAudioGateway",
+	"HumanInterfaceDeviceService",
+};
+
+G_DEFINE_TYPE(BluetoothClient, bluetooth_client, G_TYPE_OBJECT)
+
+typedef gboolean (*IterSearchFunc) (GtkTreeStore *store,
+				GtkTreeIter *iter, gpointer user_data);
+
+static gboolean iter_search(GtkTreeStore *store,
+				GtkTreeIter *iter, GtkTreeIter *parent,
+				IterSearchFunc func, gpointer user_data)
+{
+	gboolean cont, found = FALSE;
+
+	if (parent == NULL)
+		cont = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store),
+									iter);
+	else
+		cont = gtk_tree_model_iter_children(GTK_TREE_MODEL(store),
+								iter, parent);
+
+	while (cont == TRUE) {
+		GtkTreeIter child;
+
+		found = func(store, iter, user_data);
+		if (found == TRUE)
+			break;
+
+		found = iter_search(store, &child, iter, func, user_data);
+		if (found == TRUE) {
+			*iter = child;
+			break;
+		}
+
+		cont = gtk_tree_model_iter_next(GTK_TREE_MODEL(store), iter);
+	}
+
+	return found;
+}
+
+static gboolean compare_path(GtkTreeStore *store,
+					GtkTreeIter *iter, gpointer user_data)
+{
+	const gchar *path = user_data;
+	GDBusProxy *object;
+	gboolean found = FALSE;
+
+	gtk_tree_model_get(GTK_TREE_MODEL(store), iter,
+					BLUETOOTH_COLUMN_PROXY, &object, -1);
+
+	if (object != NULL) {
+		found = g_str_equal(path, g_dbus_proxy_get_object_path(object));
+		g_object_unref(object);
+	}
+
+	return found;
+}
+
+static gboolean
+compare_address (GtkTreeStore *store,
+		 GtkTreeIter *iter,
+		 gpointer user_data)
+{
+	const char *address = user_data;
+	char *tmp_address;
+	gboolean found = FALSE;
+
+	gtk_tree_model_get (GTK_TREE_MODEL(store), iter,
+			    BLUETOOTH_COLUMN_ADDRESS, &tmp_address, -1);
+	found = g_str_equal (address, tmp_address);
+	g_free (tmp_address);
+
+	return found;
+}
+
+static gboolean
+get_iter_from_path (GtkTreeStore *store,
+		    GtkTreeIter *iter,
+		    const char *path)
+{
+	return iter_search(store, iter, NULL, compare_path, (gpointer) path);
+}
+
+static gboolean
+get_iter_from_proxy(GtkTreeStore *store,
+		    GtkTreeIter *iter,
+		    GDBusProxy *proxy)
+{
+	return iter_search(store, iter, NULL, compare_path,
+			   (gpointer) g_dbus_proxy_get_object_path (proxy));
+}
+
+static gboolean
+get_iter_from_address (GtkTreeStore *store,
+		       GtkTreeIter  *iter,
+		       const char   *address,
+		       GDBusProxy   *adapter)
+{
+	GtkTreeIter parent_iter;
+
+	if (get_iter_from_proxy (store, &parent_iter, adapter) == FALSE)
+		return FALSE;
+
+	return iter_search (store, iter, &parent_iter, compare_address, (gpointer) address);
+}
+
+static char **
+device_list_uuids (GVariant *variant)
+{
+	GPtrArray *ret;
+	const char **uuids;
+	guint i;
+
+	if (variant == NULL)
+		return NULL;
+
+	uuids = g_variant_get_strv (variant, NULL);
+	if (uuids == NULL)
+		return NULL;
+
+	ret = g_ptr_array_new ();
+
+	for (i = 0; uuids[i] != NULL; i++) {
+		const char *uuid;
+
+		uuid = bluetooth_uuid_to_string (uuids[i]);
+		if (uuid == NULL)
+			continue;
+		g_ptr_array_add (ret, g_strdup (uuid));
+	}
+	g_free (uuids);
+
+	if (ret->len == 0) {
+		g_ptr_array_free (ret, TRUE);
+		return NULL;
+	}
+
+	g_ptr_array_add (ret, NULL);
+
+	return (char **) g_ptr_array_free (ret, FALSE);
+}
+
+gboolean
+bluetooth_client_get_connectable(const char **uuids)
+{
+	int i, j;
+
+	for (i = 0; uuids && uuids[i] != NULL; i++) {
+		for (j = 0; j < G_N_ELEMENTS (connectable_uuids); j++) {
+			if (g_str_equal (connectable_uuids[j], uuids[i]))
+				return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
+static void
+device_g_properties_changed (GDBusProxy      *device,
+			     GVariant        *changed_p,
+			     GStrv            invalidated_p,
+			     BluetoothClient *client)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE(client);
+	GVariantIter i;
+	const char *property;
+	GtkTreeIter iter;
+	GVariant *v;
+
+	if (get_iter_from_proxy (priv->store, &iter, device) == FALSE)
+		return;
+
+	g_variant_iter_init (&i, changed_p);
+	while (g_variant_iter_next (&i, "{&sv}", &property, &v)) {
+
+		if (g_str_equal (property, "Name") == TRUE) {
+			const gchar *name = g_variant_get_string (v, NULL);
+
+			gtk_tree_store_set (priv->store, &iter,
+					    BLUETOOTH_COLUMN_NAME, name, -1);
+		} else if (g_str_equal (property, "Alias") == TRUE) {
+			const gchar *alias = g_variant_get_string (v, NULL);
+
+			gtk_tree_store_set (priv->store, &iter,
+					    BLUETOOTH_COLUMN_ALIAS, alias, -1);
+		} else if (g_str_equal (property, "Icon") == TRUE) {
+			const gchar *icon = g_variant_get_string (v, NULL);
+
+			gtk_tree_store_set (priv->store, &iter,
+					    BLUETOOTH_COLUMN_ICON, icon, -1);
+		} else if (g_str_equal (property, "Paired") == TRUE) {
+			gboolean paired = g_variant_get_boolean (v);
+
+			gtk_tree_store_set (priv->store, &iter,
+					    BLUETOOTH_COLUMN_PAIRED, paired, -1);
+		} else if (g_str_equal (property, "Trusted") == TRUE) {
+			gboolean trusted = g_variant_get_boolean (v);
+
+			gtk_tree_store_set (priv->store, &iter,
+					    BLUETOOTH_COLUMN_TRUSTED, trusted, -1);
+		} else if (g_str_equal (property, "Connected") == TRUE) {
+			gboolean connected = g_variant_get_boolean (v);
+
+			gtk_tree_store_set (priv->store, &iter,
+					    BLUETOOTH_COLUMN_CONNECTED, connected, -1);
+		} else if (g_str_equal (property, "UUIDs") == TRUE) {
+			char **uuids;
+
+			uuids = device_list_uuids (v);
+			gtk_tree_store_set (priv->store, &iter,
+					    BLUETOOTH_COLUMN_UUIDS, uuids, -1);
+			g_strfreev (uuids);
+		} else if (g_str_equal (property, "LegacyPairing") == TRUE) {
+			gboolean legacypairing;
+
+			legacypairing = g_variant_get_boolean (v);
+			gtk_tree_store_set (priv->store, &iter,
+					    BLUETOOTH_COLUMN_LEGACYPAIRING, legacypairing,
+					    -1);
+		} else if (g_str_equal (property, "Class") == TRUE) {
+			BluetoothType type;
+
+			type = v ? bluetooth_class_to_type (g_variant_get_uint32 (v)) : BLUETOOTH_TYPE_ANY;
+			gtk_tree_store_set (priv->store, &iter,
+					    BLUETOOTH_COLUMN_TYPE, type,
+					    -1);
+		} else {
+			g_debug ("Unhandled property: %s", property);
+		}
+
+		g_variant_unref (v);
+	}
+}
+
+static void
+device_added (ObjectManager   *manager,
+	      BluetoothClient *client,
+	      const char      *path,
+	      GVariant        *variant)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE(client);
+	GDBusProxy *adapter;
+	Device1 *device;
+	Properties *properties;
+	GVariant *v, *dict;
+	const char *adapter_path, *address, *alias, *name, *icon;
+	char **uuids;
+	gboolean paired, trusted, connected;
+	int legacypairing;
+	BluetoothType type;
+	GtkTreeIter iter, parent;
+
+	device = device1_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+						 G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+						 BLUEZ_SERVICE,
+						 path,
+						 NULL,
+						 NULL);
+	if (device == NULL)
+		return;
+
+	properties = properties_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+							G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+							BLUEZ_SERVICE,
+							path,
+							NULL,
+							NULL);
+
+	dict = g_variant_lookup_value (variant, BLUEZ_DEVICE_INTERFACE,
+				       G_VARIANT_TYPE_DICTIONARY);
+
+	v = g_variant_lookup_value (dict, "Adapter", G_VARIANT_TYPE_OBJECT_PATH);
+	adapter_path = v ? g_variant_get_string (v, NULL) : NULL;
+
+	v = g_variant_lookup_value (dict, "Address", G_VARIANT_TYPE_STRING);
+	address = v ? g_variant_get_string (v, NULL) : NULL;
+
+	v = g_variant_lookup_value (dict, "Alias", G_VARIANT_TYPE_STRING);
+	alias = v ? g_variant_get_string (v, NULL) : NULL;
+
+	v = g_variant_lookup_value (dict, "Name", G_VARIANT_TYPE_STRING);
+	name = v ? g_variant_get_string (v, NULL) : NULL;
+
+	v = g_variant_lookup_value (dict, "Class", G_VARIANT_TYPE_UINT32);
+	type = v ? bluetooth_class_to_type (g_variant_get_uint32 (v)) : BLUETOOTH_TYPE_ANY;
+
+	v = g_variant_lookup_value (dict, "Icon", G_VARIANT_TYPE_STRING);
+	icon = v ? g_variant_get_string (v, NULL) : "bluetooth";
+
+	v = g_variant_lookup_value (dict, "Paired", G_VARIANT_TYPE_BOOLEAN);
+	paired = v ? g_variant_get_boolean (v) : FALSE;
+
+	v = g_variant_lookup_value (dict, "Trusted", G_VARIANT_TYPE_BOOLEAN);
+	trusted = v ? g_variant_get_boolean (v) : FALSE;
+
+	v = g_variant_lookup_value (dict, "Connected", G_VARIANT_TYPE_BOOLEAN);
+	connected = v ? g_variant_get_boolean (v) : FALSE;
+
+	v = g_variant_lookup_value (dict, "UUIDs", G_VARIANT_TYPE_STRING_ARRAY);
+	uuids = device_list_uuids (v);
+
+	v = g_variant_lookup_value (dict, "LegacyPairing", G_VARIANT_TYPE_BOOLEAN);
+	legacypairing = v ? g_variant_get_boolean (v) : -1;
+
+	if (get_iter_from_path (priv->store, &parent, adapter_path) == FALSE) {
+		g_object_unref (device);
+		return;
+	}
+
+	gtk_tree_model_get (GTK_TREE_MODEL(priv->store), &parent,
+			    BLUETOOTH_COLUMN_PROXY, &adapter, -1);
+
+	if (get_iter_from_address (priv->store, &iter, address, adapter) == FALSE) {
+		gtk_tree_store_insert_with_values (priv->store, &iter, &parent, -1,
+						   BLUETOOTH_COLUMN_ADDRESS, address,
+						   BLUETOOTH_COLUMN_ALIAS, alias,
+						   BLUETOOTH_COLUMN_NAME, name,
+						   BLUETOOTH_COLUMN_TYPE, type,
+						   BLUETOOTH_COLUMN_ICON, icon,
+						   BLUETOOTH_COLUMN_LEGACYPAIRING, legacypairing,
+						   BLUETOOTH_COLUMN_UUIDS, uuids,
+						   BLUETOOTH_COLUMN_PAIRED, paired,
+						   BLUETOOTH_COLUMN_CONNECTED, connected,
+						   BLUETOOTH_COLUMN_TRUSTED, trusted,
+						   BLUETOOTH_COLUMN_PROXY, device,
+						   BLUETOOTH_COLUMN_PROPERTIES, properties,
+						   -1);
+	} else {
+		gtk_tree_store_set(priv->store, &iter,
+				   BLUETOOTH_COLUMN_ADDRESS, address,
+				   BLUETOOTH_COLUMN_ALIAS, alias,
+				   BLUETOOTH_COLUMN_NAME, name,
+				   BLUETOOTH_COLUMN_TYPE, type,
+				   BLUETOOTH_COLUMN_ICON, icon,
+				   BLUETOOTH_COLUMN_LEGACYPAIRING, legacypairing,
+				   BLUETOOTH_COLUMN_UUIDS, uuids,
+				   BLUETOOTH_COLUMN_PAIRED, paired,
+				   BLUETOOTH_COLUMN_CONNECTED, connected,
+				   BLUETOOTH_COLUMN_TRUSTED, trusted,
+				   BLUETOOTH_COLUMN_PROXY, device,
+				   BLUETOOTH_COLUMN_PROPERTIES, properties,
+				   -1);
+	}
+	g_strfreev (uuids);
+
+	g_signal_connect (G_OBJECT (device), "g-properties-changed",
+			  G_CALLBACK (device_g_properties_changed), client);
+
+	g_object_unref (properties);
+	g_object_unref (device);
+	g_object_unref (adapter);
+}
+
+static void
+device_removed (const char      *path,
+		BluetoothClient *client)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE(client);
+	GtkTreeIter iter;
+
+	if (get_iter_from_path(priv->store, &iter, path) == TRUE) {
+		g_signal_emit (G_OBJECT (client), signals[DEVICE_REMOVED], 0, path);
+		gtk_tree_store_remove(priv->store, &iter);
+	}
+}
+
+static void
+powered_callback (GDBusProxy   *proxy,
+		  GAsyncResult *res,
+		  gpointer	data)
+{
+	GError *error = NULL;
+
+	if (!properties_call_set_finish (PROPERTIES(proxy), res, &error)) {
+		g_debug ("Call to Set Powered failed %s: %s",
+			 g_dbus_proxy_get_object_path (proxy), error->message);
+		g_error_free (error);
+	}
+
+	g_object_unref (proxy);
+}
+
+static gboolean
+adapter_set_powered (BluetoothClient *client,
+		     const char *path,
+		     gboolean powered)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE(client);
+	Properties *properties;
+	GtkTreeIter iter;
+
+	g_return_val_if_fail (BLUETOOTH_IS_CLIENT (client), FALSE);
+
+	if (get_iter_from_path (priv->store, &iter, path) == FALSE)
+		return FALSE;
+
+	gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter,
+			    BLUETOOTH_COLUMN_PROPERTIES, &properties, -1);
+
+	if (properties == NULL)
+		return FALSE;
+
+
+	properties_call_set (properties,
+			     BLUEZ_ADAPTER_INTERFACE,
+			     "Powered",
+			     g_variant_new_variant (g_variant_new_boolean (powered)),
+			     NULL,
+			     (GAsyncReadyCallback) powered_callback,
+			     NULL);
+
+	return TRUE;
+}
+
+static void
+default_adapter_changed (ObjectManager   *manager,
+			 const char      *path,
+			 BluetoothClient *client)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE(client);
+	GtkTreeIter iter;
+	GtkTreePath *tree_path;
+	gboolean powered;
+
+	g_assert (!priv->default_adapter);
+
+	if (get_iter_from_path (priv->store, &iter, path) == FALSE)
+		return;
+
+	tree_path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->store), &iter);
+	priv->default_adapter = gtk_tree_row_reference_new (GTK_TREE_MODEL (priv->store), tree_path);
+	gtk_tree_path_free (tree_path);
+
+	gtk_tree_store_set (priv->store, &iter,
+			    BLUETOOTH_COLUMN_DEFAULT, TRUE, -1);
+
+	gtk_tree_model_get (GTK_TREE_MODEL(priv->store), &iter,
+			   BLUETOOTH_COLUMN_POWERED, &powered, -1);
+
+	if (powered) {
+		g_object_notify (G_OBJECT (client), "default-adapter");
+		g_object_notify (G_OBJECT (client), "default-adapter-powered");
+		g_object_notify (G_OBJECT (client), "default-adapter-discoverable");
+		g_object_notify (G_OBJECT (client), "default-adapter-discovering");
+		g_object_notify (G_OBJECT (client), "default-adapter-name");
+		return;
+	}
+
+	/*
+	 * If the adapter is turn off (Powered = False in bluetooth) object
+	 * notifications will be sent only when a Powered = True signal arrives
+	 * from bluetoothd
+	 */
+	adapter_set_powered (client, path, TRUE);
+}
+
+static void
+adapter_g_properties_changed (GDBusProxy      *adapter,
+			      GVariant        *changed_p,
+			      GStrv            invalidated_p,
+			      BluetoothClient *client)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE(client);
+	GVariantIter i;
+	const char *property;
+	GtkTreeIter iter;
+	GVariant *v;
+	gboolean notify = FALSE;
+
+	if (get_iter_from_proxy (priv->store, &iter, adapter) == FALSE)
+		return;
+
+	g_variant_iter_init (&i, changed_p);
+	while (g_variant_iter_next (&i, "{&sv}", &property, &v)) {
+		if (g_str_equal (property, "Name") == TRUE) {
+			const gchar *name = g_variant_get_string (v, NULL);
+			gboolean is_default;
+
+			gtk_tree_store_set (priv->store, &iter,
+					    BLUETOOTH_COLUMN_NAME, name, -1);
+			gtk_tree_model_get (GTK_TREE_MODEL(priv->store), &iter,
+					    BLUETOOTH_COLUMN_DEFAULT, &is_default, -1);
+			if (is_default != FALSE) {
+				g_object_notify (G_OBJECT (client), "default-adapter-powered");
+				g_object_notify (G_OBJECT (client), "default-adapter-name");
+			}
+			notify = TRUE;
+		} else if (g_str_equal (property, "Discovering") == TRUE) {
+			gboolean discovering = g_variant_get_boolean (v);
+			gboolean is_default;
+
+			gtk_tree_store_set (priv->store, &iter,
+					    BLUETOOTH_COLUMN_DISCOVERING, discovering, -1);
+			gtk_tree_model_get (GTK_TREE_MODEL(priv->store), &iter,
+					    BLUETOOTH_COLUMN_DEFAULT, &is_default, -1);
+			if (is_default != FALSE)
+				g_object_notify (G_OBJECT (client), "default-adapter-discovering");
+			notify = TRUE;
+		} else if (g_str_equal (property, "Powered") == TRUE) {
+			gboolean powered = g_variant_get_boolean (v);
+			gboolean is_default;
+
+			gtk_tree_store_set (priv->store, &iter,
+					    BLUETOOTH_COLUMN_POWERED, powered, -1);
+			gtk_tree_model_get (GTK_TREE_MODEL(priv->store), &iter,
+					    BLUETOOTH_COLUMN_DEFAULT, &is_default, -1);
+			if (is_default != FALSE && powered) {
+				g_object_notify (G_OBJECT (client), "default-adapter");
+				g_object_notify (G_OBJECT (client), "default-adapter-powered");
+				g_object_notify (G_OBJECT (client), "default-adapter-discoverable");
+				g_object_notify (G_OBJECT (client), "default-adapter-discovering");
+				g_object_notify (G_OBJECT (client), "default-adapter-name");
+			}
+			notify = TRUE;
+		} else if (g_str_equal (property, "Discoverable") == TRUE) {
+			gboolean discoverable = g_variant_get_boolean (v);
+			gboolean is_default;
+
+			gtk_tree_store_set (priv->store, &iter,
+					    BLUETOOTH_COLUMN_DISCOVERABLE, discoverable, -1);
+			gtk_tree_model_get (GTK_TREE_MODEL(priv->store), &iter,
+					    BLUETOOTH_COLUMN_DEFAULT, &is_default, -1);
+			if (is_default != FALSE)
+				g_object_notify (G_OBJECT (client), "default-adapter-discoverable");
+			notify = TRUE;
+		}
+
+		if (notify != FALSE) {
+			GtkTreePath *path;
+
+			/* Tell the world */
+			path = gtk_tree_model_get_path (GTK_TREE_MODEL (priv->store), &iter);
+			gtk_tree_model_row_changed (GTK_TREE_MODEL (priv->store), path, &iter);
+			gtk_tree_path_free (path);
+		}
+		g_variant_unref (v);
+	}
+}
+
+static void
+adapter_added (ObjectManager   *manager,
+	       const char      *path,
+	       GVariant        *variant,
+	       BluetoothClient *client)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE(client);
+	GtkTreeIter iter;
+	Adapter1 *adapter;
+	Properties *properties;
+	const gchar *address, *name;
+	GVariant *v, *dict;
+	gboolean discovering, discoverable, powered;
+
+	adapter = adapter1_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+						   G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+						   BLUEZ_SERVICE,
+						   path,
+						   NULL,
+						   NULL);
+
+	properties = properties_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+							G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+							BLUEZ_SERVICE,
+							path,
+							NULL,
+							NULL);
+
+	dict = g_variant_lookup_value (variant, BLUEZ_ADAPTER_INTERFACE,
+                              G_VARIANT_TYPE_DICTIONARY);
+
+	v = g_variant_lookup_value (dict, "Address", G_VARIANT_TYPE_STRING);
+	address = v ? g_variant_get_string (v, NULL) : NULL;
+
+	v = g_variant_lookup_value (dict, "Name", G_VARIANT_TYPE_STRING);
+	name = v ? g_variant_get_string (v, NULL) : NULL;
+
+	v = g_variant_lookup_value (dict, "Discovering", G_VARIANT_TYPE_BOOLEAN);
+	discovering = v ? g_variant_get_boolean (v) : FALSE;
+
+	v = g_variant_lookup_value (dict, "Powered", G_VARIANT_TYPE_BOOLEAN);
+	powered = v ? g_variant_get_boolean (v) : FALSE;
+
+	v = g_variant_lookup_value (dict, "Discoverable", G_VARIANT_TYPE_BOOLEAN);
+	discoverable = v ? g_variant_get_boolean (v) : FALSE;
+
+	gtk_tree_store_insert_with_values(priv->store, &iter, NULL, -1,
+					  BLUETOOTH_COLUMN_PROXY, adapter,
+					  BLUETOOTH_COLUMN_PROPERTIES, properties,
+					  BLUETOOTH_COLUMN_ADDRESS, address,
+					  BLUETOOTH_COLUMN_NAME, name,
+					  BLUETOOTH_COLUMN_DISCOVERING, discovering,
+					  BLUETOOTH_COLUMN_DISCOVERABLE, discoverable,
+					  BLUETOOTH_COLUMN_POWERED, powered,
+					  -1);
+
+	g_signal_connect (G_OBJECT (adapter), "g-properties-changed",
+			  G_CALLBACK (adapter_g_properties_changed), client);
+
+	if (!priv->default_adapter)
+		default_adapter_changed (manager, path, client);
+
+	g_object_unref (properties);
+	g_object_unref (adapter);
+}
+
+static void
+adapter_removed (ObjectManager   *manager,
+		 const char      *path,
+		 BluetoothClient *client)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE(client);
+	GtkTreeIter iter;
+	gboolean was_default;
+
+	if (get_iter_from_path (priv->store, &iter, path) == FALSE)
+		return;
+
+	gtk_tree_model_get (GTK_TREE_MODEL(priv->store), &iter,
+			   BLUETOOTH_COLUMN_DEFAULT, &was_default, -1);
+
+	if (!was_default)
+		return;
+
+	g_clear_pointer (&priv->default_adapter, gtk_tree_row_reference_free);
+	gtk_tree_store_remove (priv->store, &iter);
+
+	if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL(priv->store),
+					   &iter)) {
+		GDBusProxy *adapter;
+		const char *adapter_path;
+
+		gtk_tree_model_get (GTK_TREE_MODEL(priv->store), &iter,
+				   BLUETOOTH_COLUMN_PROXY, &adapter, -1);
+
+		adapter_path = g_dbus_proxy_get_object_path (adapter);
+		default_adapter_changed (manager, adapter_path, client);
+
+		g_object_unref(adapter);
+	} else {
+		g_object_notify (G_OBJECT (client), "default-adapter");
+		g_object_notify (G_OBJECT (client), "default-adapter-powered");
+		g_object_notify (G_OBJECT (client), "default-adapter-discoverable");
+		g_object_notify (G_OBJECT (client), "default-adapter-discovering");
+	}
+}
+
+static void
+interface_added (BluetoothClient *client,
+		 const char *path,
+		 GVariant   *variant)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE(client);
+
+	if (g_variant_lookup_value (variant, BLUEZ_ADAPTER_INTERFACE,
+				    G_VARIANT_TYPE_DICTIONARY)) {
+		g_debug ("New Adapter interface added.");
+		adapter_added (priv->manager, path, variant, client);
+		return;
+	}
+
+	if (g_variant_lookup_value (variant, BLUEZ_DEVICE_INTERFACE,
+				    G_VARIANT_TYPE_DICTIONARY)) {
+		g_debug ("New Device interface added.");
+		device_added (priv->manager, client, path, variant);
+		return;
+	}
+}
+
+static void
+interface_removed (BluetoothClient *client,
+		   const char      *path,
+		   GVariant        *variant)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE(client);
+	const char **ifaces;
+	int i;
+
+	ifaces = g_variant_get_strv (variant, NULL);
+
+	for (i = 0 ; ifaces[i] != NULL ; i++) {
+		if (g_strcmp0(ifaces[i], BLUEZ_ADAPTER_INTERFACE) == 0) {
+			adapter_removed(priv->manager, path, client);
+			return;
+		}
+
+		if (g_strcmp0(ifaces[i], BLUEZ_DEVICE_INTERFACE) == 0) {
+			device_removed (path, client);
+			return;
+		}
+	}
+}
+
+static void
+object_manager_g_signal (GDBusProxy      *proxy,
+			 gchar           *sender_name,
+			 gchar           *signal_name,
+			 GVariant        *parameters,
+			 BluetoothClient *client)
+{
+	char *object_path;
+	GVariant *variant;
+
+	g_variant_get (parameters, "(o*)", &object_path, &variant);
+
+	if (g_strcmp0 (signal_name, "InterfacesAdded") == 0) {
+		interface_added (client, object_path, variant);
+	} else if (g_strcmp0 (signal_name, "InterfacesRemoved") == 0) {
+		interface_removed (client, object_path, variant);
+	} else {
+		g_assert_not_reached ();
+	}
+
+	g_free (object_path);
+}
+
+static void
+bluez_appeared_cb (GDBusConnection *connection,
+		   const gchar     *name,
+		   const gchar     *name_owner,
+		   BluetoothClient *client)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE(client);
+	GVariantIter iter;
+	GVariant *variant, *v, *ifaces;
+	char *key;
+
+	priv->manager = object_manager_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM,
+							       G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
+							       BLUEZ_SERVICE,
+							       BLUEZ_MANAGER_PATH,
+							       NULL,
+							       NULL);
+
+	g_signal_connect (G_OBJECT (priv->manager), "g-signal",
+			  G_CALLBACK (object_manager_g_signal), client);
+
+	variant = NULL;
+	object_manager_call_get_managed_objects_sync (OBJECT_MANAGER (priv->manager),
+						      &variant, NULL, NULL);
+	if (variant == NULL)
+		return;
+
+	g_variant_iter_init (&iter, variant);
+	while ((v = g_variant_iter_next_value (&iter))) {
+		g_variant_get (v, "{o*}", &key, &ifaces);
+		interface_added (client, key, ifaces);
+	}
+
+	g_variant_unref (variant);
+}
+
+static void
+bluez_vanished_cb (GDBusConnection *connection,
+		   const gchar     *name,
+		   BluetoothClient *client)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE(client);
+
+	g_clear_pointer (&priv->default_adapter, gtk_tree_row_reference_free);
+
+	gtk_tree_store_clear (priv->store);
+
+	g_clear_object (&priv->manager);
+}
+
+static void bluetooth_client_init(BluetoothClient *client)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE(client);
+
+	priv->store = gtk_tree_store_new(_BLUETOOTH_NUM_COLUMNS, G_TYPE_OBJECT,
+					 G_TYPE_OBJECT, G_TYPE_STRING,
+					 G_TYPE_STRING, G_TYPE_STRING,
+					 G_TYPE_UINT, G_TYPE_STRING,
+					 G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
+					 G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_INT,
+					 G_TYPE_BOOLEAN, G_TYPE_HASH_TABLE, G_TYPE_STRV);
+
+	priv->owner_change_id = g_bus_watch_name (G_BUS_TYPE_SYSTEM,
+						  BLUEZ_SERVICE,
+						  G_BUS_NAME_WATCHER_FLAGS_NONE,
+						  (GBusNameAppearedCallback) bluez_appeared_cb,
+						  (GBusNameVanishedCallback) bluez_vanished_cb,
+						  client, NULL);
+}
+
+static GDBusProxy *
+_bluetooth_client_get_default_adapter(BluetoothClient *client)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE(client);
+	GtkTreePath *path;
+	GtkTreeIter iter;
+	GDBusProxy *adapter;
+
+	g_return_val_if_fail (BLUETOOTH_IS_CLIENT (client), NULL);
+
+	if (priv->default_adapter == NULL)
+		return NULL;
+
+	path = gtk_tree_row_reference_get_path (priv->default_adapter);
+	gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->store), &iter, path);
+	gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter,
+			    BLUETOOTH_COLUMN_PROXY, &adapter, -1);
+	gtk_tree_path_free (path);
+
+	return adapter;
+}
+
+static const char*
+_bluetooth_client_get_default_adapter_path (BluetoothClient *self)
+{
+	GDBusProxy *adapter = _bluetooth_client_get_default_adapter (self);
+
+	if (adapter != NULL) {
+		const char *ret = g_dbus_proxy_get_object_path (adapter);
+		g_object_unref (adapter);
+		return ret;
+	}
+	return NULL;
+}
+
+static gboolean
+_bluetooth_client_get_default_adapter_powered (BluetoothClient *self)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE (self);
+	GtkTreePath *path;
+	GtkTreeIter iter;
+	gboolean ret;
+
+	if (priv->default_adapter == NULL)
+		return FALSE;
+
+	path = gtk_tree_row_reference_get_path (priv->default_adapter);
+	gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->store), &iter, path);
+	gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter, BLUETOOTH_COLUMN_POWERED, &ret, -1);
+	gtk_tree_path_free (path);
+
+	return ret;
+}
+
+static char *
+_bluetooth_client_get_default_adapter_name (BluetoothClient *self)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE (self);
+	GtkTreePath *path;
+	GtkTreeIter iter;
+	char *ret;
+
+	if (priv->default_adapter == NULL)
+		return NULL;
+
+	path = gtk_tree_row_reference_get_path (priv->default_adapter);
+	gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->store), &iter, path);
+	gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter, BLUETOOTH_COLUMN_NAME, &ret, -1);
+	gtk_tree_path_free (path);
+
+	return ret;
+}
+
+/**
+ * _bluetooth_client_get_discoverable:
+ * @client: a #BluetoothClient
+ *
+ * Gets the default adapter's discoverable status, cached in the adapter model.
+ *
+ * Returns: the discoverable status, or FALSE if no default adapter exists
+ */
+static gboolean
+_bluetooth_client_get_discoverable (BluetoothClient *client)
+{
+	BluetoothClientPrivate *priv;
+	GtkTreePath *path;
+	GtkTreeIter iter;
+	gboolean ret;
+
+	g_return_val_if_fail (BLUETOOTH_IS_CLIENT (client), FALSE);
+
+	priv = BLUETOOTH_CLIENT_GET_PRIVATE (client);
+	if (priv->default_adapter == NULL)
+		return FALSE;
+
+	path = gtk_tree_row_reference_get_path (priv->default_adapter);
+	gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->store), &iter, path);
+	gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter,
+                            BLUETOOTH_COLUMN_DISCOVERABLE, &ret, -1);
+
+	return ret;
+}
+
+/**
+ * _bluetooth_client_set_discoverable:
+ * @client: a #BluetoothClient object
+ * @discoverable: whether the device should be discoverable
+ * @timeout: timeout in seconds for making undiscoverable, or 0 for never
+ *
+ * Sets the default adapter's discoverable status.
+ *
+ * Return value: Whether setting the state on the default adapter was successful.
+ **/
+static gboolean
+_bluetooth_client_set_discoverable (BluetoothClient *client,
+				    gboolean discoverable,
+				    guint timeout)
+{
+	BluetoothClientPrivate *priv = BLUETOOTH_CLIENT_GET_PRIVATE (client);
+	GError *error = NULL;
+	GtkTreePath *path;
+	Properties *properties;
+	gboolean ret;
+	GtkTreeIter iter;
+
+	g_return_val_if_fail (BLUETOOTH_IS_CLIENT (client), FALSE);
+
+	if (priv->default_adapter == NULL)
+		return FALSE;
+
+	path = gtk_tree_row_reference_get_path (priv->default_adapter);
+	gtk_tree_model_get_iter (GTK_TREE_MODEL (priv->store), &iter, path);
+	gtk_tree_model_get (GTK_TREE_MODEL (priv->store), &iter,
+                            BLUETOOTH_COLUMN_PROPERTIES, &properties, -1);
+        gtk_tree_path_free (path);
+
+	if (properties == NULL)
+		return FALSE;
+
+	ret = properties_call_set_sync (properties,
+					BLUEZ_ADAPTER_INTERFACE,
+					"Discoverable",
+					g_variant_new_variant (g_variant_new_boolean (discoverable)),
+					NULL, &error);
+	if (ret == FALSE) {
+		g_warning ("Failed to set Discoverable to %d: %s", discoverable, error->message);
+		g_error_free (error);
+	} else {
+		ret = properties_call_set_sync (properties,
+						BLUEZ_ADAPTER_INTERFACE,
+						"DiscoverableTimeout",