/*

 *

 *  BlueZ - Bluetooth protocol stack for Linux

 *

 *  Copyright (C) 2005-2008  Marcel Holtmann <marcel@holtmann.org>

 *  Copyright (C) 2006-2007  Bastien Nocera <hadess@hadess.net>

 *

 *

 *  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 guint selection_table_signals[LAST_SIGNAL] = { 0 };

#define BLUETOOTH_CHOOSER_GET_PRIVATE(obj) \

	(bluetooth_chooser_get_instance_private (obj))

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_WITH_PRIVATE(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 ("%s", 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)

{

	BluetoothChooser *self = BLUETOOTH_CHOOSER (object);

	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);

	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)

{

	BluetoothChooser *self = BLUETOOTH_CHOOSER (object);

	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);

	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)

{

	BluetoothChooser *self = BLUETOOTH_CHOOSER (object);

	BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);

	if (priv->client) {

		g_signal_handler_disconnect (G_OBJECT(priv->client), priv->default_adapter_changed_id);

		priv->default_adapter_changed_id = 0;