/*

 *

 *  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

 *

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <gtk/gtk.h>

#include <glib/gi18n-lib.h>

#include "bluetooth-filter-widget.h"

#include "bluetooth-client.h"

#include "bluetooth-utils.h"

#include "gnome-bluetooth-enum-types.h"

#define BLUETOOTH_FILTER_WIDGET_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), \

						BLUETOOTH_TYPE_FILTER_WIDGET, BluetoothFilterWidgetPrivate))

typedef struct _BluetoothFilterWidgetPrivate BluetoothFilterWidgetPrivate;

struct _BluetoothFilterWidgetPrivate {

	GtkWidget *device_type_label, *device_type;

	GtkWidget *device_category_label, *device_category;

	GtkWidget *title;

	GtkWidget *chooser;

	GtkTreeModel *filter;

	/* Current filter */

	int device_type_filter;

	GtkTreeModel *device_type_filter_model;

	int device_category_filter;

	char *device_service_filter;

	guint show_device_type : 1;

	guint show_device_category : 1;

};

G_DEFINE_TYPE(BluetoothFilterWidget, bluetooth_filter_widget, GTK_TYPE_BOX)

enum {

	DEVICE_TYPE_FILTER_COL_NAME = 0,

	DEVICE_TYPE_FILTER_COL_MASK,

	DEVICE_TYPE_FILTER_NUM_COLS

};

static const char *

bluetooth_device_category_to_string (int type)

{

	switch (type) {

	case BLUETOOTH_CATEGORY_ALL:

		return N_("All categories");

	case BLUETOOTH_CATEGORY_PAIRED:

		return N_("Paired");

	case BLUETOOTH_CATEGORY_TRUSTED:

		return N_("Trusted");

	case BLUETOOTH_CATEGORY_NOT_PAIRED_OR_TRUSTED:

		return N_("Not paired or trusted");

	case BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED:

		return N_("Paired or trusted");

	default:

		return N_("Unknown");

	}

}

static void

set_combobox_from_filter (BluetoothFilterWidget *self)

{

	BluetoothFilterWidgetPrivate *priv = BLUETOOTH_FILTER_WIDGET_GET_PRIVATE(self);

	GtkTreeIter iter;

	gboolean cont;

	/* Look for an exact matching filter first */

	cont = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->device_type_filter_model),

					      &iter);

	while (cont != FALSE) {

		int mask;

		gtk_tree_model_get (GTK_TREE_MODEL (priv->device_type_filter_model), &iter,

				    DEVICE_TYPE_FILTER_COL_MASK, &mask, -1);

		if (mask == priv->device_type_filter) {

			gtk_combo_box_set_active_iter (GTK_COMBO_BOX(priv->device_type), &iter);

			return;

		}

		cont = gtk_tree_model_iter_next (GTK_TREE_MODEL (priv->device_type_filter_model), &iter);

	}

	/* Then a fuzzy match */

	cont = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->device_type_filter_model),

					      &iter);

	while (cont != FALSE) {

		int mask;

		gtk_tree_model_get (GTK_TREE_MODEL (priv->device_type_filter_model), &iter,

				    DEVICE_TYPE_FILTER_COL_MASK, &mask,

				    -1);

		if (mask & priv->device_type_filter) {

			gtk_combo_box_set_active_iter (GTK_COMBO_BOX(priv->device_type), &iter);

			return;

		}

		cont = gtk_tree_model_iter_next (GTK_TREE_MODEL (priv->device_type_filter_model), &iter);

	}

	/* Then just set the any then */

	gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->device_type_filter_model), &iter);

	gtk_combo_box_set_active_iter (GTK_COMBO_BOX(priv->device_type), &iter);

}

static void

filter_category_changed_cb (GtkComboBox *widget, gpointer data)

{

	BluetoothFilterWidget *self = BLUETOOTH_FILTER_WIDGET (data);

	BluetoothFilterWidgetPrivate *priv = BLUETOOTH_FILTER_WIDGET_GET_PRIVATE(self);

	priv->device_category_filter = gtk_combo_box_get_active (GTK_COMBO_BOX(priv->device_category));

	if (priv->filter)

		gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (priv->filter));

	g_object_notify (G_OBJECT(self), "device-category-filter");

}

static void

filter_type_changed_cb (GtkComboBox *widget, gpointer data)

{

	BluetoothFilterWidget *self = BLUETOOTH_FILTER_WIDGET (data);

	BluetoothFilterWidgetPrivate *priv = BLUETOOTH_FILTER_WIDGET_GET_PRIVATE(self);

	GtkTreeIter iter;

	if (gtk_combo_box_get_active_iter (widget, &iter) == FALSE)

		return;

	gtk_tree_model_get (GTK_TREE_MODEL (priv->device_type_filter_model), &iter,

			    DEVICE_TYPE_FILTER_COL_MASK, &(priv->device_type_filter),

			    -1);

	if (priv->filter)

		gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (priv->filter));

	g_object_notify (G_OBJECT(self), "device-type-filter");

}

/**

 * bluetooth_filter_widget_set_title:

 * @self: a #BluetoothFilterWidget.

 * @title: Title for the #BluetoothFilterWidget.

 *

 * Used to set a different title for the #BluetoothFilterWidget than the default.

 *

 **/

void

bluetooth_filter_widget_set_title (BluetoothFilterWidget *self, gchar *title)

{

	BluetoothFilterWidgetPrivate *priv = BLUETOOTH_FILTER_WIDGET_GET_PRIVATE(self);

	gtk_label_set_text (GTK_LABEL (priv->title), title);

}

static void

bluetooth_filter_widget_bind_chooser_single (BluetoothFilterWidget *self,

					     BluetoothChooser *chooser,

					     const char *property)

{

	/* NOTE: We are binding the chooser as the source so that all of its

	 * properties are pushed to the filter.

	 * The bindings will be automatically removed when one of the

	 * objects goes away */

	g_object_bind_property ((gpointer) chooser, property,

				(gpointer) self, property,

				G_BINDING_BIDIRECTIONAL);

}

/**

 * bluetooth_filter_widget_bind_filter:

 * @self: a #BluetoothFilterWidget.

 * @chooser: The #BluetoothChooser widget to bind the filter to.

 *

 * Binds a #BluetoothFilterWidget to a #BluetoothChooser such that changing the

 * #BluetoothFilterWidget results in filters being applied on the #BluetoothChooser.

 * Any properties set on a bound #BluetoothChooser will also be set on the

 * #BluetoothFilterWidget.

 *

 **/

void

bluetooth_filter_widget_bind_filter (BluetoothFilterWidget *self, BluetoothChooser *chooser)

{

	bluetooth_filter_widget_bind_chooser_single (self, chooser, "device-type-filter");

	bluetooth_filter_widget_bind_chooser_single (self, chooser, "device-category-filter");

	bluetooth_filter_widget_bind_chooser_single (self, chooser, "show-device-type");

	bluetooth_filter_widget_bind_chooser_single (self, chooser, "show-device-category");

}

static void

bluetooth_filter_widget_init(BluetoothFilterWidget *self)

{

	BluetoothFilterWidgetPrivate *priv = BLUETOOTH_FILTER_WIDGET_GET_PRIVATE(self);

	guint i;

	GtkWidget *label;

	GtkWidget *alignment;

	GtkWidget *table;

	GtkCellRenderer *renderer;

	gtk_widget_push_composite_child ();

	g_object_set (G_OBJECT (self), "orientation", GTK_ORIENTATION_VERTICAL, NULL);

	gtk_box_set_homogeneous (GTK_BOX (self), FALSE);

	gtk_box_set_spacing (GTK_BOX (self), 6);

	priv->title = gtk_label_new ("");

	/* This is the title of the filter section of the Bluetooth device chooser.

	 * It used to say Show Only Bluetooth Devices With... */

	bluetooth_filter_widget_set_title (self, _("Show:"));

	gtk_widget_show (priv->title);

	gtk_box_pack_start (GTK_BOX (self), priv->title, TRUE, TRUE, 0);

	gtk_misc_set_alignment (GTK_MISC (priv->title), 0, 0.5);

	alignment = gtk_alignment_new (0.5, 0.5, 1, 1);

	gtk_widget_show (alignment);

	gtk_box_pack_start (GTK_BOX (self), alignment, TRUE, TRUE, 0);

	table = gtk_grid_new ();

	gtk_widget_show (table);

	gtk_container_add (GTK_CONTAINER (alignment), table);

	gtk_grid_set_row_spacing (GTK_GRID (table), 6);

	gtk_grid_set_column_spacing (GTK_GRID (table), 12);

	/* The device category filter */

	label = gtk_label_new_with_mnemonic (_("Device _category:"));

	gtk_widget_set_no_show_all (label, TRUE);

	gtk_widget_show (label);

	gtk_grid_attach (GTK_GRID (table), label, 0, 0, 1, 1);

	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	priv->device_category_label = label;

	priv->device_category = gtk_combo_box_text_new ();

	gtk_widget_set_no_show_all (priv->device_category, TRUE);

	gtk_widget_show (priv->device_category);

	gtk_grid_attach (GTK_GRID (table), priv->device_category, 1, 0, 1, 1);

	gtk_widget_set_tooltip_text (priv->device_category, _("Select the device category to filter"));

	for (i = 0; i < BLUETOOTH_CATEGORY_NUM_CATEGORIES; i++) {

		gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (priv->device_category),

					        _(bluetooth_device_category_to_string (i)));

	}

	g_signal_connect (G_OBJECT (priv->device_category), "changed",

			  G_CALLBACK (filter_category_changed_cb), self);

	gtk_combo_box_set_active (GTK_COMBO_BOX (priv->device_category), priv->device_category_filter);

	if (priv->show_device_category) {

		gtk_widget_show (priv->device_category_label);

		gtk_widget_show (priv->device_category);

	}

	/* The device type filter */

	label = gtk_label_new_with_mnemonic (_("Device _type:"));

	gtk_widget_set_no_show_all (label, TRUE);

	gtk_widget_show (label);

	gtk_grid_attach (GTK_GRID (table), label, 0, 1, 1, 1);

	gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);

	priv->device_type_label = label;

	priv->device_type_filter_model = GTK_TREE_MODEL (gtk_list_store_new (DEVICE_TYPE_FILTER_NUM_COLS,

									     G_TYPE_STRING, G_TYPE_INT));

	priv->device_type = gtk_combo_box_new_with_model (priv->device_type_filter_model);

	renderer = gtk_cell_renderer_text_new ();

	gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (priv->device_type), renderer, TRUE);

	gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (priv->device_type), renderer, "text", DEVICE_TYPE_FILTER_COL_NAME);

	gtk_widget_set_no_show_all (priv->device_type, TRUE);

	gtk_widget_show (priv->device_type);

	gtk_grid_attach (GTK_GRID (table), priv->device_type, 1, 1, 1, 1);

	gtk_widget_set_tooltip_text (priv->device_type, _("Select the device type to filter"));

	gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->device_type_filter_model), NULL, G_MAXUINT32,

					   DEVICE_TYPE_FILTER_COL_NAME, _(bluetooth_type_to_filter_string (BLUETOOTH_TYPE_ANY)),

					   DEVICE_TYPE_FILTER_COL_MASK, BLUETOOTH_TYPE_ANY,

					   -1);

	gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->device_type_filter_model), NULL, G_MAXUINT32,

					   DEVICE_TYPE_FILTER_COL_NAME, _("Input devices (mice, keyboards, etc.)"),

					   DEVICE_TYPE_FILTER_COL_MASK, BLUETOOTH_TYPE_INPUT,

					   -1);

	gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->device_type_filter_model), NULL, G_MAXUINT32,

					   DEVICE_TYPE_FILTER_COL_NAME, _("Headphones, headsets and other audio devices"),

					   DEVICE_TYPE_FILTER_COL_MASK, BLUETOOTH_TYPE_AUDIO,

					   -1);

	/* The types match the types used in bluetooth-client.h */

	for (i = 1; i < _BLUETOOTH_TYPE_NUM_TYPES; i++) {

		int mask = 1 << i;

		if (mask & BLUETOOTH_TYPE_INPUT || mask & BLUETOOTH_TYPE_AUDIO)

			continue;

		gtk_list_store_insert_with_values (GTK_LIST_STORE (priv->device_type_filter_model), NULL, G_MAXUINT32,

						   DEVICE_TYPE_FILTER_COL_NAME, _(bluetooth_type_to_filter_string (mask)),

						   DEVICE_TYPE_FILTER_COL_MASK, mask,

						   -1);

	}

	g_signal_connect (G_OBJECT (priv->device_type), "changed",

			  G_CALLBACK(filter_type_changed_cb), self);

	set_combobox_from_filter (self);

	if (priv->show_device_type) {

		gtk_widget_show (priv->device_type_label);

		gtk_widget_show (priv->device_type);

	}

	/* The services filter */

	priv->device_service_filter = NULL;

	gtk_widget_pop_composite_child ();

}

static void

bluetooth_filter_widget_finalize (GObject *object)

{

	BluetoothFilterWidgetPrivate *priv = BLUETOOTH_FILTER_WIDGET_GET_PRIVATE(object);

	g_free (priv->device_service_filter);

	priv->device_service_filter = NULL;

	G_OBJECT_CLASS(bluetooth_filter_widget_parent_class)->finalize(object);

}

static void

bluetooth_filter_widget_dispose (GObject *object)

{

	BluetoothFilterWidgetPrivate *priv = BLUETOOTH_FILTER_WIDGET_GET_PRIVATE(object);

	if (priv->chooser) {

		g_object_unref (priv->chooser);

		priv->chooser = NULL;

	}

	G_OBJECT_CLASS(bluetooth_filter_widget_parent_class)->dispose(object);

}

enum {

	PROP_0,

	PROP_SHOW_DEVICE_TYPE,

	PROP_SHOW_DEVICE_CATEGORY,

	PROP_DEVICE_TYPE_FILTER,

	PROP_DEVICE_CATEGORY_FILTER,

	PROP_DEVICE_SERVICE_FILTER

};

static void

bluetooth_filter_widget_set_property (GObject *object, guint prop_id,

					 const GValue *value, GParamSpec *pspec)

{

	BluetoothFilterWidgetPrivate *priv = BLUETOOTH_FILTER_WIDGET_GET_PRIVATE(object);

	switch (prop_id) {

	case PROP_SHOW_DEVICE_TYPE:

		priv->show_device_type = g_value_get_boolean (value);

		g_object_set (G_OBJECT (priv->device_type_label), "visible", priv->show_device_type, NULL);

		g_object_set (G_OBJECT (priv->device_type), "visible", priv->show_device_type, NULL);

		break;

	case PROP_SHOW_DEVICE_CATEGORY:

		priv->show_device_category = g_value_get_boolean (value);

		g_object_set (G_OBJECT (priv->device_category_label), "visible", priv->show_device_category, NULL);

		g_object_set (G_OBJECT (priv->device_category), "visible", priv->show_device_category, NULL);

		break;

	case PROP_DEVICE_TYPE_FILTER:

		priv->device_type_filter = g_value_get_int (value);

		set_combobox_from_filter (BLUETOOTH_FILTER_WIDGET (object));

		break;

	case PROP_DEVICE_CATEGORY_FILTER:

		priv->device_category_filter = g_value_get_enum (value);

		gtk_combo_box_set_active (GTK_COMBO_BOX(priv->device_category), priv->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;

	default:

		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

		break;

	}

}

static void

bluetooth_filter_widget_get_property (GObject *object, guint prop_id,

					 GValue *value, GParamSpec *pspec)

{

	BluetoothFilterWidgetPrivate *priv = BLUETOOTH_FILTER_WIDGET_GET_PRIVATE(object);

	switch (prop_id) {

	case PROP_SHOW_DEVICE_TYPE:

		g_value_set_boolean (value, priv->show_device_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;

	default:

		G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

		break;

	}

}

static void

bluetooth_filter_widget_class_init (BluetoothFilterWidgetClass *klass)

{

	/* Use to calculate the maximum value for the

	 * device-type-filter value */

	guint i;

	int max_filter_val;

	g_type_class_add_private(klass, sizeof(BluetoothFilterWidgetPrivate));

	G_OBJECT_CLASS(klass)->dispose = bluetooth_filter_widget_dispose;

	G_OBJECT_CLASS(klass)->finalize = bluetooth_filter_widget_finalize;

	G_OBJECT_CLASS(klass)->set_property = bluetooth_filter_widget_set_property;

	G_OBJECT_CLASS(klass)->get_property = bluetooth_filter_widget_get_property;

	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_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", 1, 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));

}

/**

 * bluetooth_filter_widget_new:

 *

 * Creates a new #BluetoothFilterWidget which can be bound to a #BluetoothChooser to

 * control filtering of that #BluetoothChooser.

 * Usually used in conjunction with a #BluetoothChooser which has the "has-internal-filter"

 * property set to FALSE.

 *

 * Return value: A #BluetoothFilterWidget widget

 * 

 * Note: Must call bluetooth_filter_widget_bind_filter () to bind the #BluetoothFilterWidget

 * to a #BluetoothChooser.

 **/

GtkWidget *

bluetooth_filter_widget_new (void)

{

	return g_object_new(BLUETOOTH_TYPE_FILTER_WIDGET,

			    NULL);

}