aboutsummaryrefslogtreecommitdiffstats
path: root/libempathy-gtk/empathy-contact-blocking-dialog.c
diff options
context:
space:
mode:
authorGuillaume Desmottes <guillaume.desmottes@collabora.co.uk>2011-11-02 18:41:11 +0800
committerGuillaume Desmottes <guillaume.desmottes@collabora.co.uk>2011-11-02 18:41:11 +0800
commit40dc4074eeecb15c82d9eacb3fcd54cff7162440 (patch)
tree171e5e2923d4ccddc8f34725e91f20e37d764233 /libempathy-gtk/empathy-contact-blocking-dialog.c
parentd8153fa21a7beb4229dbba1810eb8544af91db4f (diff)
downloadgsoc2013-empathy-40dc4074eeecb15c82d9eacb3fcd54cff7162440.tar
gsoc2013-empathy-40dc4074eeecb15c82d9eacb3fcd54cff7162440.tar.gz
gsoc2013-empathy-40dc4074eeecb15c82d9eacb3fcd54cff7162440.tar.bz2
gsoc2013-empathy-40dc4074eeecb15c82d9eacb3fcd54cff7162440.tar.lz
gsoc2013-empathy-40dc4074eeecb15c82d9eacb3fcd54cff7162440.tar.xz
gsoc2013-empathy-40dc4074eeecb15c82d9eacb3fcd54cff7162440.tar.zst
gsoc2013-empathy-40dc4074eeecb15c82d9eacb3fcd54cff7162440.zip
Revert "contact-blocking-dialog: use tp-glib high level blocking API"
This reverts commit d8153fa21a7beb4229dbba1810eb8544af91db4f. I was not supposed to commit that yet; the tp-glib API hasn't been released.
Diffstat (limited to 'libempathy-gtk/empathy-contact-blocking-dialog.c')
-rw-r--r--libempathy-gtk/empathy-contact-blocking-dialog.c473
1 files changed, 317 insertions, 156 deletions
diff --git a/libempathy-gtk/empathy-contact-blocking-dialog.c b/libempathy-gtk/empathy-contact-blocking-dialog.c
index 1ec60b0ac..b000e24d4 100644
--- a/libempathy-gtk/empathy-contact-blocking-dialog.c
+++ b/libempathy-gtk/empathy-contact-blocking-dialog.c
@@ -47,6 +47,9 @@ G_DEFINE_TYPE (EmpathyContactBlockingDialog, empathy_contact_blocking_dialog,
struct _EmpathyContactBlockingDialogPrivate
{
+ /* a map of all active connections to their 'deny' channel */
+ GHashTable *channels; /* reffed TpConnection* -> reffed TpChannel* */
+
guint block_account_changed;
GtkListStore *blocked_contacts;
@@ -59,14 +62,12 @@ struct _EmpathyContactBlockingDialogPrivate
GtkWidget *info_bar;
GtkWidget *info_bar_label;
GtkWidget *remove_button;
-
- TpConnection *current_conn;
};
enum /* blocked-contacts columns */
{
COL_BLOCKED_IDENTIFIER,
- COL_BLOCKED_CONTACT,
+ COL_BLOCKED_HANDLE,
N_BLOCKED_COLUMNS
};
@@ -89,13 +90,13 @@ contact_blocking_dialog_filter_account_chooser (TpAccount *account,
gpointer callback_data,
gpointer user_data)
{
+ EmpathyContactBlockingDialog *self = user_data;
TpConnection *conn = tp_account_get_connection (account);
gboolean enable;
enable =
conn != NULL &&
- tp_proxy_has_interface_by_id (conn,
- TP_IFACE_QUARK_CONNECTION_INTERFACE_CONTACT_BLOCKING);
+ g_hash_table_lookup (self->priv->channels, conn) != NULL;
callback (enable, callback_data);
}
@@ -123,8 +124,7 @@ contact_blocking_dialog_refilter_account_chooser (
conn = empathy_account_chooser_get_connection (chooser);
enabled = (empathy_account_chooser_get_account (chooser) != NULL &&
conn != NULL &&
- tp_proxy_has_interface_by_id (conn,
- TP_IFACE_QUARK_CONNECTION_INTERFACE_CONTACT_BLOCKING));
+ g_hash_table_lookup (self->priv->channels, conn) != NULL);
if (!enabled)
DEBUG ("No account selected");
@@ -135,63 +135,56 @@ contact_blocking_dialog_refilter_account_chooser (
contact_blocking_dialog_account_changed (self->priv->account_chooser, self);
}
+static void contact_blocking_dialog_inspected_handles (TpConnection *,
+ const char **, const GError *, gpointer, GObject *);
+
static void
-contact_blocking_dialog_add_blocked (
+contact_blocking_dialog_add_contacts_to_list (
EmpathyContactBlockingDialog *self,
- GPtrArray *blocked)
+ TpConnection *conn,
+ GArray *handles)
{
- EmpathyContactBlockingDialogPrivate *priv = GET_PRIVATE (self);
- guint i;
-
- if (blocked == NULL)
- return;
-
- for (i = 0; i < blocked->len; i++)
- {
- TpContact *contact = g_ptr_array_index (blocked, i);
-
- gtk_list_store_insert_with_values (priv->blocked_contacts, NULL, -1,
- COL_BLOCKED_IDENTIFIER, tp_contact_get_identifier (contact),
- COL_BLOCKED_CONTACT, contact,
- -1);
- }
+ if (handles->len > 0)
+ tp_cli_connection_call_inspect_handles (conn, -1,
+ TP_HANDLE_TYPE_CONTACT, handles,
+ contact_blocking_dialog_inspected_handles,
+ g_boxed_copy (DBUS_TYPE_G_UINT_ARRAY, handles),
+ (GDestroyNotify) g_array_unref, G_OBJECT (self));
}
static void
-blocked_contacts_changed_cb (TpConnection *conn,
- GPtrArray *added,
- GPtrArray *removed,
- EmpathyContactBlockingDialog *self)
+contact_blocking_dialog_inspected_handles (TpConnection *conn,
+ const char **identifiers,
+ const GError *in_error,
+ gpointer user_data,
+ GObject *self)
{
- GtkTreeModel *model = GTK_TREE_MODEL (self->priv->blocked_contacts);
- GtkTreeIter iter;
- gboolean valid;
+ EmpathyContactBlockingDialogPrivate *priv = GET_PRIVATE (self);
+ GArray *handles = user_data;
+ guint i;
- DEBUG ("blocked contacts changed on %s: %u added, %u removed",
- get_pretty_conn_name (conn), added->len, removed->len);
+ if (in_error != NULL)
+ {
+ DEBUG ("Failed to inspect handles: %s", in_error->message);
+ return;
+ }
- /* add contacts */
- contact_blocking_dialog_add_blocked (self, added);
+ DEBUG ("Adding %u identifiers", handles->len);
- /* remove contacts */
- valid = gtk_tree_model_get_iter_first (model, &iter);
- while (valid)
+ for (i = 0; i < handles->len; i++)
{
- TpContact *contact;
+ const char *identifier = identifiers[i];
+ TpHandle handle = g_array_index (handles, TpHandle, i);
- gtk_tree_model_get (model, &iter,
- COL_BLOCKED_CONTACT, &contact,
+ gtk_list_store_insert_with_values (priv->blocked_contacts, NULL, -1,
+ COL_BLOCKED_IDENTIFIER, identifier,
+ COL_BLOCKED_HANDLE, handle,
-1);
-
- if (tp_g_ptr_array_contains (removed, contact))
- valid = gtk_list_store_remove (self->priv->blocked_contacts, &iter);
- else
- valid = gtk_tree_model_iter_next (model, &iter);
-
- g_object_unref (contact);
}
}
+DECLARE_CALLBACK (contact_blocking_dialog_connection_prepared);
+
static void
contact_blocking_dialog_connection_status_changed (TpAccount *account,
guint old_status,
@@ -208,6 +201,8 @@ contact_blocking_dialog_connection_status_changed (TpAccount *account,
case TP_CONNECTION_STATUS_DISCONNECTED:
DEBUG ("Connection %s invalidated", get_pretty_conn_name (conn));
+ /* remove the channel from the hash table */
+ g_hash_table_remove (self->priv->channels, conn);
contact_blocking_dialog_refilter_account_chooser (self);
break;
@@ -217,10 +212,65 @@ contact_blocking_dialog_connection_status_changed (TpAccount *account,
case TP_CONNECTION_STATUS_CONNECTED:
DEBUG ("Connection %s reconnected", get_pretty_conn_name (conn));
- contact_blocking_dialog_refilter_account_chooser (self);
+ tp_proxy_prepare_async (conn, NULL,
+ contact_blocking_dialog_connection_prepared, self);
+ }
+}
+
+static void
+contact_blocking_dialog_deny_channel_members_changed (TpChannel *channel,
+ const char *message,
+ GArray *added,
+ GArray *removed,
+ GArray *local_pending,
+ GArray *remote_pending,
+ TpHandle actor,
+ guint reason,
+ EmpathyContactBlockingDialog *self)
+{
+ TpConnection *conn = tp_channel_borrow_connection (channel);
+ GtkTreeModel *model = GTK_TREE_MODEL (self->priv->blocked_contacts);
+ GtkTreeIter iter;
+ TpIntset *removed_set;
+ gboolean valid;
+
+ /* we only care about changes to the selected connection */
+ /* FIXME: can we compare proxy pointers directly? */
+ if (tp_strdiff (
+ tp_proxy_get_object_path (tp_channel_borrow_connection (channel)),
+ tp_proxy_get_object_path (empathy_account_chooser_get_connection (
+ EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser)))))
+ return;
+
+ DEBUG ("deny list changed on %s: %u added, %u removed",
+ get_pretty_conn_name (conn), added->len, removed->len);
+
+ /* add contacts */
+ contact_blocking_dialog_add_contacts_to_list (self, conn, added);
+
+ /* remove contacts */
+ removed_set = tp_intset_from_array (removed);
+
+ valid = gtk_tree_model_get_iter_first (model, &iter);
+ while (valid)
+ {
+ TpHandle handle;
+
+ gtk_tree_model_get (model, &iter,
+ COL_BLOCKED_HANDLE, &handle,
+ -1);
+
+ if (tp_intset_is_member (removed_set, handle))
+ valid = gtk_list_store_remove (self->priv->blocked_contacts, &iter);
+ else
+ valid = gtk_tree_model_iter_next (model, &iter);
}
+
+ tp_intset_destroy (removed_set);
}
+DECLARE_CALLBACK (contact_blocking_dialog_connection_prepared);
+
static void
contact_blocking_dialog_am_prepared (GObject *am,
GAsyncResult *result,
@@ -242,100 +292,166 @@ contact_blocking_dialog_am_prepared (GObject *am,
for (ptr = accounts; ptr != NULL; ptr = ptr->next)
{
TpAccount *account = ptr->data;
+ TpConnection *conn;
tp_g_signal_connect_object (account, "status-changed",
G_CALLBACK (contact_blocking_dialog_connection_status_changed),
self, 0);
- contact_blocking_dialog_refilter_account_chooser (self);
+ conn = tp_account_get_connection (TP_ACCOUNT (account));
+
+ if (conn != NULL)
+ {
+ tp_proxy_prepare_async (conn, NULL,
+ contact_blocking_dialog_connection_prepared, self);
+ }
}
g_list_free (accounts);
}
+static void contact_blocking_dialog_got_deny_channel (TpConnection *,
+ gboolean, const char *, GHashTable *, const GError *, gpointer, GObject *);
+
static void
-contact_blocking_dialog_set_error (EmpathyContactBlockingDialog *self,
- const GError *error)
+contact_blocking_dialog_connection_prepared (GObject *conn,
+ GAsyncResult *result,
+ gpointer user_data)
{
- const char *msg = NULL;
+ EmpathyContactBlockingDialog *self = user_data;
+ GHashTable *request;
+ GError *error = NULL;
- if (error->domain == TP_ERRORS)
+ if (!tp_proxy_prepare_finish (conn, result, &error))
{
- if (error->code == TP_ERROR_INVALID_HANDLE)
- msg = _("Unknown or invalid identifier");
- else if (error->code == TP_ERROR_NOT_AVAILABLE)
- msg = _("Contact blocking temporarily unavailable");
- else if (error->code == TP_ERROR_NOT_CAPABLE)
- msg = _("Contact blocking unavailable");
- else if (error->code == TP_ERROR_PERMISSION_DENIED)
- msg = _("Permission Denied");
+ DEBUG ("Failed to prepare connection %s: %s",
+ get_pretty_conn_name ((TpConnection *) conn), error->message);
+ g_error_free (error);
+ return;
}
- if (msg == NULL)
- msg = _("Could not block contact");
+ /* request the deny channel */
+ request = tp_asv_new (
+ TP_PROP_CHANNEL_CHANNEL_TYPE,
+ G_TYPE_STRING,
+ TP_IFACE_CHANNEL_TYPE_CONTACT_LIST,
- gtk_label_set_text (GTK_LABEL (self->priv->info_bar_label), msg);
- gtk_widget_show (self->priv->info_bar);
+ TP_PROP_CHANNEL_TARGET_HANDLE_TYPE,
+ G_TYPE_UINT,
+ TP_HANDLE_TYPE_LIST,
+
+ TP_PROP_CHANNEL_TARGET_ID,
+ G_TYPE_STRING,
+ "deny",
+
+ NULL);
+
+ tp_cli_connection_interface_requests_call_ensure_channel (
+ TP_CONNECTION (conn), -1, request,
+ contact_blocking_dialog_got_deny_channel, NULL, NULL, G_OBJECT (self));
+
+ g_hash_table_destroy (request);
}
+DECLARE_CALLBACK (contact_blocking_dialog_deny_channel_prepared);
+
static void
-block_cb (GObject *source,
- GAsyncResult *result,
- gpointer user_data)
+contact_blocking_dialog_got_deny_channel (TpConnection *conn,
+ gboolean yours,
+ const char *channel_path,
+ GHashTable *props,
+ const GError *in_error,
+ gpointer user_data,
+ GObject *self)
{
- EmpathyContactBlockingDialog *self = user_data;
+ TpChannel *channel;
GError *error = NULL;
- if (!tp_contact_block_finish (TP_CONTACT (source), result,
- &error))
+ const GQuark features[] = {
+ TP_CHANNEL_FEATURE_CORE,
+ TP_CHANNEL_FEATURE_GROUP,
+ 0 };
+
+ if (in_error != NULL)
{
- DEBUG ("Error blocking contacts: %s", error->message);
+ DEBUG ("Failed to get 'deny' channel on %s: %s",
+ get_pretty_conn_name (conn), in_error->message);
+ return;
+ }
- contact_blocking_dialog_set_error (
- EMPATHY_CONTACT_BLOCKING_DIALOG (self), error);
+ channel = tp_channel_new_from_properties (conn, channel_path, props, &error);
+ if (error != NULL)
+ {
+ DEBUG ("Failed to create channel proxy on %s: %s",
+ get_pretty_conn_name (conn), in_error->message);
g_error_free (error);
return;
}
- DEBUG ("Contact blocked");
+ tp_proxy_prepare_async (channel, features,
+ contact_blocking_dialog_deny_channel_prepared, self);
}
static void
-block_contact_got_contact(TpConnection *conn,
- guint n_contacts,
- TpContact * const *contacts,
- const gchar * const *requested_ids,
- GHashTable *failed_id_errors,
- const GError *error,
- gpointer user_data,
- GObject *weak_object)
+contact_blocking_dialog_deny_channel_prepared (GObject *channel,
+ GAsyncResult *result,
+ gpointer user_data)
{
- EmpathyContactBlockingDialog *self =
- EMPATHY_CONTACT_BLOCKING_DIALOG (weak_object);
- gchar *id = user_data;
+ EmpathyContactBlockingDialog *self = user_data;
+ TpConnection *conn;
+ GError *error = NULL;
- if (error != NULL)
- goto error;
+ if (!tp_proxy_prepare_finish (channel, result, &error))
+ {
+ DEBUG ("Failed to prepare channel %s: %s",
+ tp_proxy_get_object_path (channel), error->message);
+ g_error_free (error);
+ return;
+ }
- error = g_hash_table_lookup (failed_id_errors, id);
- if (error != NULL)
- goto error;
+ conn = tp_channel_borrow_connection (TP_CHANNEL (channel));
- tp_contact_block_async (contacts[0], FALSE, block_cb, self);
- goto finally;
+ DEBUG ("Channel %s prepared for connection %s",
+ tp_proxy_get_object_path (channel), get_pretty_conn_name (conn));
-error:
- DEBUG ("Error getting contact on %s: %s",
- get_pretty_conn_name (conn), error->message);
+ g_hash_table_insert (self->priv->channels,
+ g_object_ref (conn), channel);
+ contact_blocking_dialog_refilter_account_chooser (self);
- contact_blocking_dialog_set_error (
- EMPATHY_CONTACT_BLOCKING_DIALOG (self), error);
+ tp_g_signal_connect_object (channel, "group-members-changed",
+ G_CALLBACK (contact_blocking_dialog_deny_channel_members_changed),
+ self, 0);
+}
-finally:
- g_free (id);
+static void
+contact_blocking_dialog_set_error (EmpathyContactBlockingDialog *self,
+ const GError *error)
+{
+ const char *msg = NULL;
+
+ if (error->domain == TP_ERRORS)
+ {
+ if (error->code == TP_ERROR_INVALID_HANDLE)
+ msg = _("Unknown or invalid identifier");
+ else if (error->code == TP_ERROR_NOT_AVAILABLE)
+ msg = _("Contact blocking temporarily unavailable");
+ else if (error->code == TP_ERROR_NOT_CAPABLE)
+ msg = _("Contact blocking unavailable");
+ else if (error->code == TP_ERROR_PERMISSION_DENIED)
+ msg = _("Permission Denied");
+ }
+
+ if (msg == NULL)
+ msg = _("Could not block contact");
+
+ gtk_label_set_text (GTK_LABEL (self->priv->info_bar_label), msg);
+ gtk_widget_show (self->priv->info_bar);
}
+static void contact_blocking_dialog_add_contact_got_handle (TpConnection *,
+ const GArray *, const GError *, gpointer, GObject *);
+
static void
contact_blocking_dialog_add_contact (GtkWidget *widget,
EmpathyContactBlockingDialog *self)
@@ -350,80 +466,136 @@ contact_blocking_dialog_add_contact (GtkWidget *widget,
DEBUG ("Looking up handle for '%s' on %s",
identifiers[0], get_pretty_conn_name (conn));
- tp_connection_get_contacts_by_id (conn, 1, identifiers,
- 0, NULL, block_contact_got_contact,
- g_strdup (identifiers[0]), NULL, G_OBJECT (self));
+ tp_cli_connection_call_request_handles (conn, -1,
+ TP_HANDLE_TYPE_CONTACT, identifiers,
+ contact_blocking_dialog_add_contact_got_handle,
+ NULL, NULL, G_OBJECT (self));
gtk_entry_set_text (GTK_ENTRY (self->priv->add_contact_entry), "");
gtk_widget_hide (self->priv->info_bar);
}
static void
-unblock_cb (GObject *source,
- GAsyncResult *result,
- gpointer user_data)
+contact_blocking_dialog_added_contact (TpChannel *, const GError *,
+ gpointer, GObject *);
+
+static void
+contact_blocking_dialog_add_contact_got_handle (TpConnection *conn,
+ const GArray *handles,
+ const GError *in_error,
+ gpointer user_data,
+ GObject *self)
{
- EmpathyContactBlockingDialog *self = user_data;
- GError *error = NULL;
+ EmpathyContactBlockingDialogPrivate *priv = GET_PRIVATE (self);
+ TpChannel *channel = g_hash_table_lookup (priv->channels, conn);
- if (!tp_connection_unblock_contacts_finish (TP_CONNECTION (source), result,
- &error))
+ if (in_error != NULL)
{
- DEBUG ("Error unblocking contacts: %s", error->message);
+ DEBUG ("Error getting handle on %s: %s",
+ get_pretty_conn_name (conn), in_error->message);
contact_blocking_dialog_set_error (
- EMPATHY_CONTACT_BLOCKING_DIALOG (self), error);
+ EMPATHY_CONTACT_BLOCKING_DIALOG (self), in_error);
- g_error_free (error);
return;
}
- DEBUG ("Contacts unblocked");
+ g_return_if_fail (handles->len == 1);
+
+ DEBUG ("Adding handle %u to deny channel on %s",
+ g_array_index (handles, TpHandle, 0), get_pretty_conn_name (conn));
+
+ tp_cli_channel_interface_group_call_add_members (channel, -1,
+ handles, "",
+ contact_blocking_dialog_added_contact, NULL, NULL, self);
}
static void
+contact_blocking_dialog_added_contact (TpChannel *channel,
+ const GError *in_error,
+ gpointer user_data,
+ GObject *self)
+{
+ if (in_error != NULL)
+ {
+ DEBUG ("Error adding contact to deny list %s: %s",
+ tp_proxy_get_object_path (channel), in_error->message);
+
+ contact_blocking_dialog_set_error (
+ EMPATHY_CONTACT_BLOCKING_DIALOG (self), in_error);
+
+ return;
+ }
+
+ DEBUG ("Contact added to %s", tp_proxy_get_object_path (channel));
+}
+
+static void
+contact_blocking_dialog_removed_contacts (TpChannel *,
+ const GError *, gpointer, GObject *);
+
+static void
contact_blocking_dialog_remove_contacts (GtkWidget *button,
EmpathyContactBlockingDialog *self)
{
TpConnection *conn = empathy_account_chooser_get_connection (
EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser));
+ TpChannel *channel = g_hash_table_lookup (self->priv->channels, conn);
GtkTreeModel *model;
GList *rows, *ptr;
- GPtrArray *contacts;
+ GArray *handles = g_array_new (FALSE, FALSE, sizeof (TpHandle));
rows = gtk_tree_selection_get_selected_rows (self->priv->selection, &model);
- contacts = g_ptr_array_new_with_free_func (g_object_unref);
-
for (ptr = rows; ptr != NULL; ptr = ptr->next)
{
GtkTreePath *path = ptr->data;
GtkTreeIter iter;
- TpContact *contact;
+ TpHandle handle;
if (!gtk_tree_model_get_iter (model, &iter, path))
continue;
gtk_tree_model_get (model, &iter,
- COL_BLOCKED_CONTACT, &contact,
+ COL_BLOCKED_HANDLE, &handle,
-1);
- g_ptr_array_add (contacts, contact);
-
+ g_array_append_val (handles, handle);
gtk_tree_path_free (path);
}
g_list_free (rows);
- if (contacts->len > 0)
+ if (handles->len > 0)
{
- DEBUG ("Unblocking %u contacts", contacts->len);
+ DEBUG ("Removing %u handles", handles->len);
+
+ tp_cli_channel_interface_group_call_remove_members (channel, -1,
+ handles, "",
+ contact_blocking_dialog_removed_contacts,
+ NULL, NULL, G_OBJECT (self));
+ }
- tp_connection_unblock_contacts_async (conn, contacts->len,
- (TpContact * const *) contacts->pdata, unblock_cb, self);
+ g_array_unref (handles);
+}
+
+static void
+contact_blocking_dialog_removed_contacts (TpChannel *channel,
+ const GError *in_error,
+ gpointer user_data,
+ GObject *self)
+{
+ if (in_error != NULL)
+ {
+ DEBUG ("Error removing contacts from deny list: %s", in_error->message);
+
+ contact_blocking_dialog_set_error (
+ EMPATHY_CONTACT_BLOCKING_DIALOG (self), in_error);
+
+ return;
}
- g_ptr_array_unref (contacts);
+ DEBUG ("Contacts removed");
}
static void
@@ -432,7 +604,8 @@ contact_blocking_dialog_account_changed (GtkWidget *account_chooser,
{
TpConnection *conn = empathy_account_chooser_get_connection (
EMPATHY_ACCOUNT_CHOOSER (account_chooser));
- GPtrArray *blocked;
+ TpChannel *channel;
+ GArray *blocked;
EmpathyContactManager *contact_manager;
EmpathyTpContactList *contact_list;
GList *members, *ptr;
@@ -440,37 +613,29 @@ contact_blocking_dialog_account_changed (GtkWidget *account_chooser,
if (self->priv->block_account_changed > 0)
return;
- if (conn == self->priv->current_conn)
- return;
-
/* clear the lists of contacts */
gtk_list_store_clear (self->priv->blocked_contacts);
gtk_list_store_clear (self->priv->completion_contacts);
- if (self->priv->current_conn != NULL)
- {
- g_signal_handlers_disconnect_by_func (self->priv->current_conn,
- blocked_contacts_changed_cb, self);
-
- g_clear_object (&self->priv->current_conn);
- }
-
if (conn == NULL)
return;
DEBUG ("Account changed: %s", get_pretty_conn_name (conn));
- self->priv->current_conn = g_object_ref (conn);
+ /* load the deny list */
+ channel = g_hash_table_lookup (self->priv->channels, conn);
- tp_g_signal_connect_object (conn, "blocked-contacts-changed",
- G_CALLBACK (blocked_contacts_changed_cb), self, 0);
+ if (channel == NULL)
+ return;
+
+ g_return_if_fail (TP_IS_CHANNEL (channel));
- blocked = tp_connection_get_blocked_contacts (conn);
+ blocked = tp_intset_to_array (tp_channel_group_get_members (channel));
- DEBUG ("%u contacts blocked on %s",
- blocked != NULL ? blocked->len : 0, get_pretty_conn_name (conn));
+ DEBUG ("%u contacts on blocked list", blocked->len);
- contact_blocking_dialog_add_blocked (self, blocked);
+ contact_blocking_dialog_add_contacts_to_list (self, conn, blocked);
+ g_array_unref (blocked);
/* load the completion list */
g_return_if_fail (empathy_contact_manager_initialized ());
@@ -585,7 +750,7 @@ contact_blocking_dialog_dispose (GObject *self)
{
EmpathyContactBlockingDialogPrivate *priv = GET_PRIVATE (self);
- g_clear_object (&priv->current_conn);
+ tp_clear_pointer (&priv->channels, g_hash_table_destroy);
G_OBJECT_CLASS (empathy_contact_blocking_dialog_parent_class)->dispose (self);
}
@@ -613,12 +778,14 @@ empathy_contact_blocking_dialog_init (EmpathyContactBlockingDialog *self)
GtkEntryCompletion *completion;
TpAccountManager *am;
GtkStyleContext *context;
- TpSimpleClientFactory *factory;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
EMPATHY_TYPE_CONTACT_BLOCKING_DIALOG,
EmpathyContactBlockingDialogPrivate);
+ self->priv->channels = g_hash_table_new_full (NULL, NULL,
+ g_object_unref, g_object_unref);
+
gtk_window_set_title (GTK_WINDOW (self), _("Edit Blocked Contacts"));
gtk_dialog_add_button (GTK_DIALOG (self),
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
@@ -666,9 +833,8 @@ empathy_contact_blocking_dialog_init (EmpathyContactBlockingDialog *self)
/* build the contact entry */
self->priv->completion_contacts = gtk_list_store_new (N_COMPLETION_COLUMNS,
G_TYPE_STRING, /* id */
- G_TYPE_STRING, /* text */
- TP_TYPE_CONTACT); /* contact */
-
+ G_TYPE_UINT, /* handle */
+ G_TYPE_STRING); /* text */
completion = gtk_entry_completion_new ();
gtk_entry_completion_set_model (completion,
GTK_TREE_MODEL (self->priv->completion_contacts));
@@ -708,11 +874,6 @@ empathy_contact_blocking_dialog_init (EmpathyContactBlockingDialog *self)
/* prepare the account manager */
am = tp_account_manager_dup ();
-
- factory = tp_proxy_get_factory (am);
- tp_simple_client_factory_add_connection_features_varargs (factory,
- TP_CONNECTION_FEATURE_CONTACT_BLOCKING, NULL);
-
tp_proxy_prepare_async (am, NULL, contact_blocking_dialog_am_prepared, self);
g_object_unref (am);