static void
device_selected_cb(GObject *object,
GParamSpec *spec,
adapter_data *adapter)
{
char *address;
gboolean connected;
address = bluetooth_chooser_get_selected_device (BLUETOOTH_CHOOSER (adapter->chooser));
connected = bluetooth_chooser_get_selected_device_is_connected (BLUETOOTH_CHOOSER (adapter->chooser));
update_buttons(adapter, (address != NULL), connected);
}
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;
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);
}
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 remove_callback(GtkWidget *button, gpointer user_data)
{
adapter_data *adapter = user_data;
char *address;
address = bluetooth_chooser_get_selected_device (BLUETOOTH_CHOOSER (adapter->chooser));
if (address == NULL) {
g_free (address);
return;
}
if (bluetooth_chooser_remove_selected_device (BLUETOOTH_CHOOSER (adapter->chooser)))
bluetooth_plugin_manager_device_deleted (address);
g_free (address);
}
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 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
bluetooth_chooser_get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
BluetoothChooser *self = BLUETOOTH_CHOOSER(object);
BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE(self);
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 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 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
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 disconnect_callback(GtkWidget *button, gpointer user_data)
{
adapter_data *adapter = user_data;
GValue value = { 0, };
DBusGProxy *device;
if (bluetooth_chooser_get_selected_device_info (BLUETOOTH_CHOOSER (adapter->chooser),
"proxy", &value) == FALSE) {
return;
}
device = g_value_dup_object (&value);
g_value_unset (&value);
if (device == NULL)
return;
dbus_g_proxy_call(device, "Disconnect", NULL,
G_TYPE_INVALID, G_TYPE_INVALID);
g_object_unref(device);
gtk_widget_set_sensitive(button, FALSE);
}
static GtkWidget*
get_contacts_widget (NstPlugin *plugin)
{
GtkWidget *chooser;
const char *filter = "OBEXObjectPush";
combo = bluetooth_chooser_combo_new ();
g_object_get (G_OBJECT (combo), "chooser", &chooser, NULL);
g_object_set (chooser,
"show-searching", TRUE,
"show-device-type", FALSE,
"show-device-category", FALSE,
"show-pairing", TRUE,
"show-connected", FALSE,
"device-service-filter", filter,
NULL);
set_last_used_device ();
bluetooth_chooser_start_discovery (BLUETOOTH_CHOOSER (chooser));
gtk_container_set_border_width (GTK_CONTAINER (combo), 0);
gtk_widget_show (combo);
return combo;
}
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_set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
BluetoothChooser *self = BLUETOOTH_CHOOSER (object);
BluetoothChooserPrivate *priv = BLUETOOTH_CHOOSER_GET_PRIVATE (self);
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;
}
}
