diff options
29 files changed, 1967 insertions, 32 deletions
diff --git a/extensions/Connection_Interface_Contact_Blocking.xml b/extensions/Connection_Interface_Contact_Blocking.xml new file mode 100644 index 000000000..543d43a5c --- /dev/null +++ b/extensions/Connection_Interface_Contact_Blocking.xml @@ -0,0 +1,172 @@ +<?xml version="1.0" ?> +<node name="/Connection_Interface_Contact_Blocking" xmlns:tp="http://telepathy.freedesktop.org/wiki/DbusSpec#extensions-v0"> + <tp:copyright>Copyright © 2009-2010 Collabora Ltd.</tp:copyright> + <tp:copyright>Copyright © 2009 Nokia Corporation</tp:copyright> + <tp:license xmlns="http://www.w3.org/1999/xhtml"> + <p>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.</p> + + <p>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.</p> + + <p>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 Street, Fifth Floor, Boston, MA 02110-1301, + USA.</p> + </tp:license> + <interface name="org.freedesktop.Telepathy.Connection.Interface.ContactBlocking.DRAFT" + tp:causes-havoc="experimental"> + <tp:requires interface="org.freedesktop.Telepathy.Connection"/> + + <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> + <p>An interface for connections where contacts can be blocked from + communicating with this user and receiving this user's presence.</p> + + <p>When this interface becomes stable, it will replace the <tp:dbus-ref + namespace="org.freedesktop.Telepathy.Channel.Type" + >ContactList</tp:dbus-ref> channel with TargetHandleType + Handle_Type_List and TargetID 'deny'.</p> + </tp:docstring> + + <method name="BlockContacts" tp:name-for-bindings="Block_Contacts"> + <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> + <p>Direct the server to block some contacts. The precise effect is + protocol-dependent, but SHOULD include ignoring all current and + subsequent communications from the given contacts, avoiding sending + presence to them in future, and if they were already receiving the + local user's presence, behaving as if the local user went + offline.</p> + + <p><em>FIXME: do we need to allow this on protocols where it won't + persist, or where we can't edit the block lists?</em></p> + </tp:docstring> + + <arg name="Contacts" type="au" direction="in" tp:type="Contact_Handle[]"> + <tp:docstring>Some contacts to block.</tp:docstring> + </arg> + + <arg name="Report_Abusive" type="b" direction="in"> + <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> + <p>In addition to blocking, report these contacts as abusive to the + server administrators.</p> + + <p>Clients can determine whether this capability is available by + checking the + <tp:member-ref>ContactBlockingCapabilities</tp:member-ref> + property. If the capability is not present and this argument is + true, the error <tp:error-ref>NotCapable</tp:error-ref> SHOULD + be raised.</p> + + <tp:rationale> + Some protocol libraries, in their conformance requirements, + require the ability to report blocked contacts as abusive. + </tp:rationale> + </tp:docstring> + </arg> + + <tp:possible-errors> + <tp:error name="org.freedesktop.Telepathy.Error.Disconnected"/> + <tp:error name="org.freedesktop.Telepathy.Error.InvalidHandle"/> + <tp:error name="org.freedesktop.Telepathy.Error.NetworkError"/> + <tp:error name="org.freedesktop.Telepathy.Error.NotCapable"/> + </tp:possible-errors> + </method> + + <method name="UnblockContacts" tp:name-for-bindings="Unblock_Contacts"> + <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> + <p>Reverse the effects of a previous call to + <tp:member-ref>BlockContacts</tp:member-ref>.</p> + </tp:docstring> + + <arg name="Contacts" type="au" direction="in" tp:type="Contact_Handle[]"> + <tp:docstring>Some contacts to unblock.</tp:docstring> + </arg> + + <tp:possible-errors> + <tp:error name="org.freedesktop.Telepathy.Error.Disconnected"/> + <tp:error name="org.freedesktop.Telepathy.Error.InvalidHandle"/> + <tp:error name="org.freedesktop.Telepathy.Error.NetworkError"/> + </tp:possible-errors> + </method> + + <method name="RequestBlockedContacts" + tp:name-for-bindings="Request_Blocked_Contacts"> + <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> + <p>List the contacts that are blocked.</p> + + <p>Clients SHOULD allow a relatively long timeout for calls to this + method, since on some protocols contact blocking is part of the + contact list, which can take a significant time to retrieve.</p> + </tp:docstring> + + <arg name="Contacts" type="au" direction="out" tp:type="Contact_Handle[]"> + <tp:docstring>The list of blocked contacts.</tp:docstring> + </arg> + + <tp:possible-errors> + <tp:error name="org.freedesktop.Telepathy.Error.Disconnected"/> + <tp:error name="org.freedesktop.Telepathy.Error.InvalidHandle"/> + <tp:error name="org.freedesktop.Telepathy.Error.NetworkError"/> + </tp:possible-errors> + </method> + + <signal name="BlockedContactsChanged" + tp:name-for-bindings="Blocked_Contacts_Changed"> + <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> + <p>Emitted when the list of blocked contacts is first retrieved + (before returning from any pending calls to + <tp:member-ref>RequestBlockedContacts</tp:member-ref>), and + whenever the list of blocked contacts subsequently changes.</p> + </tp:docstring> + + <arg name="BlockedContacts" type="au" tp:type="Contact_Handle[]"> + <tp:docstring>Contacts added to the result of + <tp:member-ref>RequestBlockedContacts</tp:member-ref>.</tp:docstring> + </arg> + + <arg name="UnblockedContacts" type="au" tp:type="Contact_Handle[]"> + <tp:docstring>Contacts removed from the result of + <tp:member-ref>RequestBlockedContacts</tp:member-ref>.</tp:docstring> + </arg> + </signal> + + <tp:contact-attribute name="blocked" type="b"> + <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> + <p>True if the contact would be in the result of + <tp:member-ref>RequestBlockedContacts</tp:member-ref>; + False or omitted if the contact is not blocked, or if it is + unknown whether the contact is blocked.</p> + </tp:docstring> + </tp:contact-attribute> + + <property name="ContactBlockingCapabilities" + tp:name-for-bindings="Contact_Blocking_Capabilities" + tp:type="Contact_Blocking_Capabilities" type="u" access="read" + tp:immutable="yes"> + <tp:docstring xmlns="http://www.w3.org/1999/xhtml"> + <p>Additional capabilities for contact blocking (i.e. whether we can + report abusive contacts).</p> + + <p><b>Note:</b> there is no capability for supporting blocking itself, + the presence of this interface indicates that contact blocking is + supported.</p> + </tp:docstring> + </property> + + <tp:flags name="Contact_Blocking_Capabilities" type="u" + value-prefix="Contact_Blocking_Capability"> + <tp:flag suffix="Can_Report_Abusive" value="1"> + <tp:docstring> + This protocol is capable of reporting abusive contacts to the server + administrators. + </tp:docstring> + </tp:flag> + </tp:flags> + + </interface> +</node> +<!-- vim:set sw=2 sts=2 et ft=xml: --> diff --git a/extensions/Makefile.am b/extensions/Makefile.am index d0f104821..b3147f301 100644 --- a/extensions/Makefile.am +++ b/extensions/Makefile.am @@ -18,6 +18,7 @@ EXTRA_DIST = \ Authentication_TLS_Certificate.xml \ Channel_Interface_Credentials_Storage.xml \ Channel_Type_Server_TLS_Connection.xml \ + Connection_Interface_Contact_Blocking.xml \ $(NULL) noinst_LTLIBRARIES = libemp-extensions.la diff --git a/extensions/misc.xml b/extensions/misc.xml index b1f6e88eb..9b153f11a 100644 --- a/extensions/misc.xml +++ b/extensions/misc.xml @@ -10,5 +10,6 @@ <xi:include href="Authentication_TLS_Certificate.xml" /> <xi:include href="Channel_Interface_Credentials_Storage.xml" /> <xi:include href="Channel_Type_Server_TLS_Connection.xml" /> +<xi:include href="Connection_Interface_Contact_Blocking.xml" /> </tp:spec> diff --git a/libempathy-gtk/Makefile.am b/libempathy-gtk/Makefile.am index 47b416fa0..18f9a1cdc 100644 --- a/libempathy-gtk/Makefile.am +++ b/libempathy-gtk/Makefile.am @@ -39,6 +39,7 @@ libempathy_gtk_handwritten_source = \ empathy-chat-text-view.c \ empathy-chat-view.c \ empathy-chat.c \ + empathy-contact-blocking-dialog.c \ empathy-contact-dialogs.c \ empathy-contact-list-store.c \ empathy-contact-list-view.c \ @@ -98,6 +99,7 @@ libempathy_gtk_headers = \ empathy-chat-text-view.h \ empathy-chat-view.h \ empathy-chat.h \ + empathy-contact-blocking-dialog.h \ empathy-contact-dialogs.h \ empathy-contact-list-store.h \ empathy-contact-list-view.h \ @@ -177,6 +179,7 @@ uidir = $(datadir)/empathy ui_DATA = \ empathy-contact-widget.ui \ empathy-contact-dialogs.ui \ + empathy-contact-blocking-dialog.ui \ empathy-account-widget-generic.ui \ empathy-account-widget-jabber.ui \ empathy-account-widget-msn.ui \ diff --git a/libempathy-gtk/empathy-chat.c b/libempathy-gtk/empathy-chat.c index 72e906079..b696963ac 100644 --- a/libempathy-gtk/empathy-chat.c +++ b/libempathy-gtk/empathy-chat.c @@ -3590,7 +3590,8 @@ empathy_chat_get_contact_menu (EmpathyChat *chat) menu = empathy_contact_menu_new (priv->remote_contact, EMPATHY_CONTACT_FEATURE_CALL | EMPATHY_CONTACT_FEATURE_LOG | - EMPATHY_CONTACT_FEATURE_INFO); + EMPATHY_CONTACT_FEATURE_INFO | + EMPATHY_CONTACT_FEATURE_BLOCK); } return menu; diff --git a/libempathy-gtk/empathy-contact-blocking-dialog.c b/libempathy-gtk/empathy-contact-blocking-dialog.c new file mode 100644 index 000000000..a46820c5d --- /dev/null +++ b/libempathy-gtk/empathy-contact-blocking-dialog.c @@ -0,0 +1,791 @@ +/* + * empathy-contact-blocking-dialog.c + * + * EmpathyContactBlockingDialog + * + * Copyright (C) 2011 Collabora Ltd. + * + * 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 + * + * Authors: Danielle Madeley <danielle.madeley@collabora.co.uk> + */ + +#include <glib/gi18n.h> + +#include <libempathy/empathy-utils.h> + +#include <libempathy/empathy-contact-manager.h> +#include <libempathy/empathy-tp-contact-list.h> + +#include <libempathy-gtk/empathy-account-chooser.h> +#include <libempathy-gtk/empathy-ui-utils.h> + +#include "empathy-contact-blocking-dialog.h" + +#define DEBUG_FLAG EMPATHY_DEBUG_OTHER +#include <libempathy/empathy-debug.h> + +#define GET_PRIVATE(o) (EMPATHY_CONTACT_BLOCKING_DIALOG (o)->priv) +#define DECLARE_CALLBACK(func) \ + static void func (GObject *, GAsyncResult *, gpointer); + +G_DEFINE_TYPE (EmpathyContactBlockingDialog, empathy_contact_blocking_dialog, + GTK_TYPE_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; + GtkListStore *completion_contacts; + GtkTreeSelection *selection; + + GtkWidget *account_chooser; + GtkWidget *add_button; + GtkWidget *add_contact_entry; + GtkWidget *info_bar; + GtkWidget *info_bar_label; + GtkWidget *remove_button; +}; + +enum /* blocked-contacts columns */ +{ + COL_IDENTIFIER, + COL_HANDLE, + N_COLUMNS +}; + +static const char * +get_pretty_conn_name (TpConnection *conn) +{ + return tp_proxy_get_object_path (conn) + strlen (TP_CONN_OBJECT_PATH_BASE); +} + +static void +contact_blocking_dialog_filter_account_chooser (TpAccount *account, + EmpathyAccountChooserFilterResultCallback callback, + gpointer callback_data, + gpointer user_data) +{ + EmpathyContactBlockingDialog *self = user_data; + TpConnection *conn = tp_account_get_connection (account); + gboolean enable; + + enable = + conn != NULL && + g_hash_table_lookup (self->priv->channels, conn) != NULL; + + callback (enable, callback_data); +} + +static void contact_blocking_dialog_account_changed (GtkWidget *, + EmpathyContactBlockingDialog *); + +static void +contact_blocking_dialog_refilter_account_chooser ( + EmpathyContactBlockingDialog *self) +{ + EmpathyAccountChooser *chooser = + EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser); + TpConnection *conn; + gboolean enabled; + + DEBUG ("Refiltering account chooser"); + + /* set the filter to refilter the account chooser */ + self->priv->block_account_changed++; + empathy_account_chooser_set_filter (chooser, + contact_blocking_dialog_filter_account_chooser, self); + self->priv->block_account_changed--; + + conn = empathy_account_chooser_get_connection (chooser); + enabled = (empathy_account_chooser_get_account (chooser) != NULL && + conn != NULL && + g_hash_table_lookup (self->priv->channels, conn) != NULL); + + if (!enabled) + DEBUG ("No account selected"); + + gtk_widget_set_sensitive (self->priv->add_button, enabled); + gtk_widget_set_sensitive (self->priv->add_contact_entry, enabled); + + 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_contacts_to_list ( + EmpathyContactBlockingDialog *self, + TpConnection *conn, + GArray *handles) +{ + 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 +contact_blocking_dialog_inspected_handles (TpConnection *conn, + const char **identifiers, + const GError *in_error, + gpointer user_data, + GObject *self) +{ + EmpathyContactBlockingDialogPrivate *priv = GET_PRIVATE (self); + GArray *handles = user_data; + guint i; + + if (in_error != NULL) + { + DEBUG ("Failed to inspect handles: %s", in_error->message); + return; + } + + DEBUG ("Adding %u identifiers", handles->len); + + for (i = 0; i < handles->len; i++) + { + const char *identifier = identifiers[i]; + TpHandle handle = g_array_index (handles, TpHandle, i); + + gtk_list_store_insert_with_values (priv->blocked_contacts, NULL, -1, + COL_IDENTIFIER, identifier, + COL_HANDLE, handle, + -1); + } +} + +DECLARE_CALLBACK (contact_blocking_dialog_connection_prepared); + +static void +contact_blocking_dialog_connection_status_changed (TpAccount *account, + guint old_status, + guint new_status, + guint reason, + const char *dbus_reason, + GHashTable *details, + EmpathyContactBlockingDialog *self) +{ + TpConnection *conn = tp_account_get_connection (account); + + switch (new_status) + { + 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; + + case TP_CONNECTION_STATUS_CONNECTING: + break; + + case TP_CONNECTION_STATUS_CONNECTED: + DEBUG ("Connection %s reconnected", get_pretty_conn_name (conn)); + + 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: %u added, %u removed", 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_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, + gpointer user_data) +{ + EmpathyContactBlockingDialog *self = user_data; + GList *accounts, *ptr; + GError *error = NULL; + + if (!tp_proxy_prepare_finish (am, result, &error)) + { + g_critical ("Could not prepare Account Manager: %s", error->message); + g_error_free (error); + return; + } + + accounts = tp_account_manager_get_valid_accounts (TP_ACCOUNT_MANAGER (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); + + 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_connection_prepared (GObject *conn, + GAsyncResult *result, + gpointer user_data) +{ + EmpathyContactBlockingDialog *self = user_data; + GHashTable *request; + GError *error = NULL; + + if (!tp_proxy_prepare_finish (conn, result, &error)) + { + DEBUG ("Failed to prepare connection: %s", error->message); + g_error_free (error); + return; + } + + /* request the deny channel */ + request = tp_asv_new ( + TP_PROP_CHANNEL_CHANNEL_TYPE, + G_TYPE_STRING, + TP_IFACE_CHANNEL_TYPE_CONTACT_LIST, + + 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 +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) +{ + TpChannel *channel; + GError *error = NULL; + + const GQuark features[] = { + TP_CHANNEL_FEATURE_CORE, + TP_CHANNEL_FEATURE_GROUP, + 0 }; + + if (in_error != NULL) + { + DEBUG ("Failed to get 'deny' channel: %s", in_error->message); + return; + } + + channel = tp_channel_new_from_properties (conn, channel_path, props, &error); + + if (error != NULL) + { + DEBUG ("Failed to create channel proxy: %s", error->message); + g_error_free (error); + return; + } + + tp_proxy_prepare_async (channel, features, + contact_blocking_dialog_deny_channel_prepared, self); +} + +static void +contact_blocking_dialog_deny_channel_prepared (GObject *channel, + GAsyncResult *result, + gpointer user_data) +{ + EmpathyContactBlockingDialog *self = user_data; + TpConnection *conn; + GError *error = NULL; + + if (!tp_proxy_prepare_finish (channel, result, &error)) + { + DEBUG ("Failed to prepare channel: %s", error->message); + g_error_free (error); + return; + } + + conn = tp_channel_borrow_connection (TP_CHANNEL (channel)); + + DEBUG ("Channel prepared for connection %s", get_pretty_conn_name (conn)); + + g_hash_table_insert (self->priv->channels, + g_object_ref (conn), channel); + contact_blocking_dialog_refilter_account_chooser (self); + + tp_g_signal_connect_object (channel, "group-members-changed", + G_CALLBACK (contact_blocking_dialog_deny_channel_members_changed), + self, 0); +} + +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) +{ + TpConnection *conn = empathy_account_chooser_get_connection ( + EMPATHY_ACCOUNT_CHOOSER (self->priv->account_chooser)); + const char *identifiers[2] = { NULL, }; + + identifiers[0] = gtk_entry_get_text ( + GTK_ENTRY (self->priv->add_contact_entry)); + + DEBUG ("Looking up handle for '%s'", identifiers[0]); + + 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 +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) +{ + EmpathyContactBlockingDialogPrivate *priv = GET_PRIVATE (self); + TpChannel *channel = g_hash_table_lookup (priv->channels, conn); + + if (in_error != NULL) + { + DEBUG ("Error getting handle: %s", in_error->message); + + contact_blocking_dialog_set_error ( + EMPATHY_CONTACT_BLOCKING_DIALOG (self), in_error); + + return; + } + + g_return_if_fail (handles->len == 1); + + DEBUG ("Adding handle %u to deny channel", + g_array_index (handles, TpHandle, 0)); + + 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", in_error->message); + + contact_blocking_dialog_set_error ( + EMPATHY_CONTACT_BLOCKING_DIALOG (self), in_error); + + return; + } + + DEBUG ("Contact added"); +} + +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; + GArray *handles = g_array_new (FALSE, FALSE, sizeof (TpHandle)); + + rows = gtk_tree_selection_get_selected_rows (self->priv->selection, &model); + + for (ptr = rows; ptr != NULL; ptr = ptr->next) + { + GtkTreePath *path = ptr->data; + GtkTreeIter iter; + TpHandle handle; + + if (!gtk_tree_model_get_iter (model, &iter, path)) + continue; + + gtk_tree_model_get (model, &iter, + COL_HANDLE, &handle, + -1); + + g_array_append_val (handles, handle); + gtk_tree_path_free (path); + } + + g_list_free (rows); + + if (handles->len > 0) + { + 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)); + } + + 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; + } + + DEBUG ("Contacts removed"); +} + +static void +contact_blocking_dialog_account_changed (GtkWidget *account_chooser, + EmpathyContactBlockingDialog *self) +{ + TpConnection *conn = empathy_account_chooser_get_connection ( + EMPATHY_ACCOUNT_CHOOSER (account_chooser)); + TpChannel *channel; + GArray *blocked; + EmpathyContactManager *contact_manager; + EmpathyTpContactList *contact_list; + GList *members, *ptr; + + if (self->priv->block_account_changed > 0) + return; + + /* clear the lists of contacts */ + gtk_list_store_clear (self->priv->blocked_contacts); + gtk_list_store_clear (self->priv->completion_contacts); + + if (conn == NULL) + return; + + DEBUG ("Account changed: %s", get_pretty_conn_name (conn)); + + /* load the deny list */ + channel = g_hash_table_lookup (self->priv->channels, conn); + + if (channel == NULL) + return; + + g_return_if_fail (TP_IS_CHANNEL (channel)); + + blocked = tp_intset_to_array (tp_channel_group_get_members (channel)); + + DEBUG ("%u contacts on blocked list", blocked->len); + + 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 ()); + + DEBUG ("Loading contacts"); + + contact_manager = empathy_contact_manager_dup_singleton (); + contact_list = empathy_contact_manager_get_list (contact_manager, conn); + members = empathy_contact_list_get_members ( + EMPATHY_CONTACT_LIST (contact_list)); + + for (ptr = members; ptr != NULL; ptr = ptr->next) + { + EmpathyContact *contact = ptr->data; + + gtk_list_store_insert_with_values (self->priv->completion_contacts, + NULL, -1, + COL_IDENTIFIER, empathy_contact_get_id (contact), + -1); + + g_object_unref (contact); + } + + g_list_free (members); + g_object_unref (contact_manager); +} + +static void +contact_blocking_dialog_view_selection_changed (GtkTreeSelection *selection, + EmpathyContactBlockingDialog *self) +{ + GList *rows = gtk_tree_selection_get_selected_rows (selection, NULL); + + /* update the sensitivity of the remove button */ + gtk_widget_set_sensitive (self->priv->remove_button, rows != NULL); + + g_list_foreach (rows, (GFunc) gtk_tree_path_free, NULL); + g_list_free (rows); +} + +static void +contact_blocking_dialog_dispose (GObject *self) +{ + EmpathyContactBlockingDialogPrivate *priv = GET_PRIVATE (self); + + tp_clear_pointer (&priv->channels, g_hash_table_destroy); + + G_OBJECT_CLASS (empathy_contact_blocking_dialog_parent_class)->dispose (self); +} + +static void +empathy_contact_blocking_dialog_class_init ( + EmpathyContactBlockingDialogClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->dispose = contact_blocking_dialog_dispose; + + g_type_class_add_private (gobject_class, + sizeof (EmpathyContactBlockingDialogPrivate)); +} + +static void +empathy_contact_blocking_dialog_init (EmpathyContactBlockingDialog *self) +{ + GtkBuilder *gui; + char *filename; + GtkWidget *contents; + GtkWidget *account_hbox, *blocked_contacts_view; + GtkEntryCompletion *completion; + TpAccountManager *am; + + 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); + + filename = empathy_file_lookup ("empathy-contact-blocking-dialog.ui", + "libempathy-gtk"); + + gui = empathy_builder_get_file (filename, + "contents", &contents, + "account-hbox", &account_hbox, + "add-button", &self->priv->add_button, + "add-contact-entry", &self->priv->add_contact_entry, + "blocked-contacts", &self->priv->blocked_contacts, + "blocked-contacts-view", &blocked_contacts_view, + "remove-button", &self->priv->remove_button, + NULL); + + empathy_builder_connect (gui, self, + "add-button", "clicked", contact_blocking_dialog_add_contact, + "add-contact-entry", "activate", contact_blocking_dialog_add_contact, + "remove-button", "clicked", contact_blocking_dialog_remove_contacts, + NULL); + + /* add the contents to the dialog */ + gtk_container_add ( + GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (self))), + contents); + gtk_widget_show (contents); + + /* set up the tree selection */ + self->priv->selection = gtk_tree_view_get_selection ( + GTK_TREE_VIEW (blocked_contacts_view)); + gtk_tree_selection_set_mode (self->priv->selection, GTK_SELECTION_MULTIPLE); + g_signal_connect (self->priv->selection, "changed", + G_CALLBACK (contact_blocking_dialog_view_selection_changed), self); + + /* build the contact entry */ + self->priv->completion_contacts = gtk_list_store_new (1, G_TYPE_STRING); + completion = gtk_entry_completion_new (); + gtk_entry_completion_set_model (completion, + GTK_TREE_MODEL (self->priv->completion_contacts)); + gtk_entry_completion_set_text_column (completion, COL_IDENTIFIER); + gtk_entry_set_completion (GTK_ENTRY (self->priv->add_contact_entry), + completion); + g_object_unref (completion); + g_object_unref (self->priv->completion_contacts); + + /* add the account chooser */ + self->priv->account_chooser = empathy_account_chooser_new (); + contact_blocking_dialog_refilter_account_chooser (self); + g_signal_connect (self->priv->account_chooser, "changed", + G_CALLBACK (contact_blocking_dialog_account_changed), self); + + gtk_box_pack_start (GTK_BOX (account_hbox), self->priv->account_chooser, + TRUE, TRUE, 0); + gtk_widget_show (self->priv->account_chooser); + + /* add an error warning info bar */ + self->priv->info_bar = gtk_info_bar_new (); + gtk_box_pack_start (GTK_BOX (contents), self->priv->info_bar, FALSE, TRUE, 0); + gtk_info_bar_set_message_type (GTK_INFO_BAR (self->priv->info_bar), + GTK_MESSAGE_ERROR); + + self->priv->info_bar_label = gtk_label_new (""); + gtk_container_add (GTK_CONTAINER ( + gtk_info_bar_get_content_area (GTK_INFO_BAR (self->priv->info_bar))), + self->priv->info_bar_label); + gtk_widget_show (self->priv->info_bar_label); + + /* prepare the account manager */ + am = tp_account_manager_dup (); + tp_proxy_prepare_async (am, NULL, contact_blocking_dialog_am_prepared, self); + g_object_unref (am); + + g_free (filename); + g_object_unref (gui); +} + +GtkWidget * +empathy_contact_blocking_dialog_new (GtkWindow *parent) +{ + GtkWidget *self = g_object_new (EMPATHY_TYPE_CONTACT_BLOCKING_DIALOG, + NULL); + + if (parent != NULL) + { + gtk_window_set_transient_for (GTK_WINDOW (self), parent); + } + + return self; +} diff --git a/libempathy-gtk/empathy-contact-blocking-dialog.h b/libempathy-gtk/empathy-contact-blocking-dialog.h new file mode 100644 index 000000000..96451c6c3 --- /dev/null +++ b/libempathy-gtk/empathy-contact-blocking-dialog.h @@ -0,0 +1,60 @@ +/* + * empathy-contact-blocking-dialog.h + * + * EmpathyContactBlockingDialog + * + * Copyright (C) 2011 Collabora Ltd. + * + * 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 + * + * Authors: Danielle Madeley <danielle.madeley@collabora.co.uk> + */ + +#ifndef __EMPATHY_CONTACT_BLOCKING_DIALOG_H__ +#define __EMPATHY_CONTACT_BLOCKING_DIALOG_H__ + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define EMPATHY_TYPE_CONTACT_BLOCKING_DIALOG (empathy_contact_blocking_dialog_get_type ()) +#define EMPATHY_CONTACT_BLOCKING_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EMPATHY_TYPE_CONTACT_BLOCKING_DIALOG, EmpathyContactBlockingDialog)) +#define EMPATHY_CONTACT_BLOCKING_DIALOG_CLASS(obj) (G_TYPE_CHECK_CLASS_CAST ((obj), EMPATHY_TYPE_CONTACT_BLOCKING_DIALOG, EmpathyContactBlockingDialogClass)) +#define EMPATHY_IS_CONTACT_BLOCKING_DIALOG(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EMPATHY_TYPE_CONTACT_BLOCKING_DIALOG)) +#define EMPATHY_IS_CONTACT_BLOCKING_DIALOG_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE ((obj), EMPATHY_TYPE_CONTACT_BLOCKING_DIALOG)) +#define EMPATHY_CONTACT_BLOCKING_DIALOG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), EMPATHY_TYPE_CONTACT_BLOCKING_DIALOG, EmpathyContactBlockingDialogClass)) + +typedef struct _EmpathyContactBlockingDialog EmpathyContactBlockingDialog; +typedef struct _EmpathyContactBlockingDialogClass EmpathyContactBlockingDialogClass; +typedef struct _EmpathyContactBlockingDialogPrivate EmpathyContactBlockingDialogPrivate; + +struct _EmpathyContactBlockingDialog +{ + GtkDialog parent; + EmpathyContactBlockingDialogPrivate *priv; +}; + +struct _EmpathyContactBlockingDialogClass +{ + GtkDialogClass parent_class; +}; + +GType empathy_contact_blocking_dialog_get_type (void); + +GtkWidget *empathy_contact_blocking_dialog_new (GtkWindow *parent); + +G_END_DECLS + +#endif diff --git a/libempathy-gtk/empathy-contact-blocking-dialog.ui b/libempathy-gtk/empathy-contact-blocking-dialog.ui new file mode 100644 index 000000000..b2ea89b81 --- /dev/null +++ b/libempathy-gtk/empathy-contact-blocking-dialog.ui @@ -0,0 +1,149 @@ +<?xml version="1.0" encoding="UTF-8"?> +<interface> + <requires lib="gtk+" version="2.16"/> + <!-- interface-naming-policy project-wide --> + <object class="GtkListStore" id="blocked-contacts"> + <columns> + <!-- column-name identifier --> + <column type="gchararray"/> + <!-- column-name handle --> + <column type="guint"/> + </columns> + </object> + <object class="GtkVBox" id="contents"> + <property name="visible">True</property> + <property name="border_width">6</property> + <property name="spacing">6</property> + <child> + <object class="GtkHBox" id="account-hbox"> + <property name="visible">True</property> + <property name="spacing">6</property> + <child> + <object class="GtkLabel" id="label1"> + <property name="visible">True</property> + <property name="xalign">0</property> + <property name="label" translatable="yes">Account:</property> + </object> + <packing> + <property name="expand">False</property> + <property name="position">0</property> + </packing> + </child> + <child> + <placeholder/> + </child> + </object> + <packing> + <property name="expand">False</property> + <property name="position">0</property> + </packing> + </child> + <child> + <object class="GtkHBox" id="hbox1"> + <property name="visible">True</property> + <property name="spacing">6</property> + <child> + <object class="GtkScrolledWindow" id="scrolledwindow1"> + <property name="visible">True</property> + <property name="can_focus">True</property> + <property name="hscrollbar_policy">never</property> + <property name="vscrollbar_policy">automatic</property> + <property name="shadow_type">etched-in</property> + <child> + <object class="GtkTreeView" id="blocked-contacts-view"> + <property name="visible">True</property> + <property name="can_focus">True</property> + <property name="model">blocked-contacts</property> + <property name="headers_clickable">False</property> + <property name="search_column">0</property> + <child> + <object class="GtkTreeViewColumn" id="treeviewcolumn1"> + <property name="title">Blocked Contacts</property> + <property name="sort_indicator">True</property> + <property name="sort_column_id">0</property> + <child> + <object class="GtkCellRendererText" id="cellrenderertext1"/> + <attributes> + <attribute name="text">0</attribute> + </attributes> + </child> + </object> + </child> + </object> + </child> + </object> + <packing> + <property name="position">0</property> + </packing> + </child> + <child> + <object class="GtkVButtonBox" id="vbuttonbox1"> + <property name="visible">True</property> + <property name="layout_style">start</property> + <child> + <object class="GtkButton" id="remove-button"> + <property name="label">gtk-remove</property> + <property name="visible">True</property> + <property name="sensitive">False</property> + <property name="can_focus">True</property> + <property name="receives_default">True</property> + <property name="use_stock">True</property> + </object> + <packing> + <property name="expand">False</property> + <property name="fill">False</property> + <property name="position">0</property> + </packing> + </child> + </object> + <packing> + <property name="expand">False</property> + <property name="position">1</property> + </packing> + </child> + </object> + <packing> + <property name="position">1</property> + </packing> + </child> + <child> + <object class="GtkHBox" id="add-contact-hbox"> + <property name="visible">True</property> + <property name="spacing">6</property> + <child> + <object class="GtkEntry" id="add-contact-entry"> + <property name="visible">True</property> + <property name="can_focus">True</property> + <property name="invisible_char">●</property> + </object> + <packing> + <property name="position">0</property> + </packing> + </child> + <child> + <object class="GtkButton" id="add-button"> + <property name="label">gtk-add</property> + <property name="visible">True</property> + <property name="can_focus">True</property> + <property name="receives_default">True</property> + <property name="use_stock">True</property> + </object> + <packing> + <property name="expand">False</property> + <property name="position">1</property> + </packing> + </child> + </object> + <packing> + <property name="expand">False</property> + <property name="position">2</property> + </packing> + </child> + </object> + <object class="GtkSizeGroup" id="sizegroup1"> + <widgets> + <widget name="add-button"/> + <widget name="remove-button"/> + </widgets> + </object> +</interface> diff --git a/libempathy-gtk/empathy-contact-dialogs.c b/libempathy-gtk/empathy-contact-dialogs.c index fb67c41cc..d16062eff 100644 --- a/libempathy-gtk/empathy-contact-dialogs.c +++ b/libempathy-gtk/empathy-contact-dialogs.c @@ -17,6 +17,7 @@ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA * * Authors: Xavier Claessens <xclaesse@gmail.com> + * Danielle Madeley <danielle.madeley@collabora.co.uk> */ #include <config.h> @@ -83,9 +84,29 @@ subscription_dialog_response_cb (GtkDialog *dialog, empathy_contact_list_remove (EMPATHY_CONTACT_LIST (manager), contact, ""); } + else if (response == GTK_RESPONSE_REJECT) { + gboolean abusive; + + /* confirm the blocking */ + if (empathy_block_contact_dialog_show (GTK_WINDOW (dialog), + contact, &abusive)) { + empathy_contact_list_remove ( + EMPATHY_CONTACT_LIST (manager), + contact, ""); + empathy_contact_list_set_blocked ( + EMPATHY_CONTACT_LIST (manager), + contact, TRUE, abusive); + } else { + /* if they don't confirm, return back to the + * first dialog */ + goto finally; + } + } subscription_dialogs = g_list_remove (subscription_dialogs, dialog); gtk_widget_destroy (GTK_WIDGET (dialog)); + +finally: g_object_unref (manager); } @@ -99,8 +120,13 @@ empathy_subscription_dialog_show (EmpathyContact *contact, GtkWidget *hbox_subscription; GtkWidget *vbox; GtkWidget *contact_widget; + GtkWidget *block_user_button; GList *l; gchar *filename; + EmpathyContactManager *manager; + EmpathyContactListFlags flags; + + manager = empathy_contact_manager_dup_singleton (); g_return_if_fail (EMPATHY_IS_CONTACT (contact)); @@ -117,6 +143,7 @@ empathy_subscription_dialog_show (EmpathyContact *contact, gui = empathy_builder_get_file (filename, "subscription_request_dialog", &dialog, "hbox_subscription", &hbox_subscription, + "block-user-button", &block_user_button, NULL); g_free (filename); g_object_unref (gui); @@ -161,10 +188,17 @@ empathy_subscription_dialog_show (EmpathyContact *contact, G_CALLBACK (subscription_dialog_response_cb), contact_widget); + flags = empathy_contact_manager_get_flags_for_connection (manager, + empathy_contact_get_connection (contact)); + + if (flags & EMPATHY_CONTACT_LIST_CAN_BLOCK) + gtk_widget_show (block_user_button); + if (parent) { gtk_window_set_transient_for (GTK_WINDOW (dialog), parent); } + g_object_unref (manager); gtk_widget_show (dialog); } @@ -468,3 +502,72 @@ empathy_new_contact_dialog_show_with_contact (GtkWindow *parent, gtk_widget_show (dialog); } +/** + * empathy_block_contact_dialog_show: + * @parent: the parent of this dialog (or %NULL) + * @contact: the contact for this dialog + * @abusive: a pointer to store the value of the abusive contact check box + * (or %NULL) + * + * Returns: %TRUE if the user wishes to block the contact + */ +gboolean +empathy_block_contact_dialog_show (GtkWindow *parent, + EmpathyContact *contact, + gboolean *abusive) +{ + EmpathyContactManager *manager; + EmpathyContactListFlags flags; + GtkWidget *dialog; + GtkWidget *abusive_check = NULL; + int res; + + manager = empathy_contact_manager_dup_singleton (); + flags = empathy_contact_manager_get_flags_for_connection (manager, + empathy_contact_get_connection (contact)); + + dialog = gtk_message_dialog_new (parent, + GTK_DIALOG_MODAL, + GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, + _("Block %s?"), + empathy_contact_get_alias (contact)); + + gtk_message_dialog_format_secondary_text ( + GTK_MESSAGE_DIALOG (dialog), + _("Are you sure you want to block '%s' from " + "contacting you again?"), + empathy_contact_get_alias (contact)); + gtk_dialog_add_buttons (GTK_DIALOG (dialog), + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + _("_Block"), GTK_RESPONSE_REJECT, + NULL); + + /* ask the user if they want to also report the contact as abusive */ + if (flags & EMPATHY_CONTACT_LIST_CAN_REPORT_ABUSIVE) { + GtkWidget *vbox; + + vbox = gtk_message_dialog_get_message_area ( + GTK_MESSAGE_DIALOG (dialog)); + abusive_check = gtk_check_button_new_with_mnemonic ( + _("_Report this contact as abusive")); + + gtk_box_pack_start (GTK_BOX (vbox), abusive_check, + FALSE, TRUE, 0); + gtk_widget_show (abusive_check); + } + + res = gtk_dialog_run (GTK_DIALOG (dialog)); + if (abusive != NULL) { + if (abusive_check != NULL) { + *abusive = gtk_toggle_button_get_active ( + GTK_TOGGLE_BUTTON (abusive_check)); + } else { + *abusive = FALSE; + } + } + + gtk_widget_destroy (dialog); + g_object_unref (manager); + + return res == GTK_RESPONSE_REJECT; +} diff --git a/libempathy-gtk/empathy-contact-dialogs.h b/libempathy-gtk/empathy-contact-dialogs.h index 8c3ffc6c1..7dc1db10f 100644 --- a/libempathy-gtk/empathy-contact-dialogs.h +++ b/libempathy-gtk/empathy-contact-dialogs.h @@ -39,6 +39,9 @@ void empathy_contact_personal_dialog_show (GtkWindow *parent); void empathy_new_contact_dialog_show (GtkWindow *parent); void empathy_new_contact_dialog_show_with_contact (GtkWindow *parent, EmpathyContact *contact); +gboolean empathy_block_contact_dialog_show (GtkWindow *parent, + EmpathyContact *contact, + gboolean *abusive); G_END_DECLS diff --git a/libempathy-gtk/empathy-contact-dialogs.ui b/libempathy-gtk/empathy-contact-dialogs.ui index c18bfabb4..ecafddb69 100644 --- a/libempathy-gtk/empathy-contact-dialogs.ui +++ b/libempathy-gtk/empathy-contact-dialogs.ui @@ -1,13 +1,14 @@ -<?xml version="1.0"?> -<!--*- mode: xml -*--> +<?xml version="1.0" encoding="UTF-8"?> <interface> + <!-- interface-requires gtk+ 2.12 --> + <!-- interface-naming-policy toplevel-contextual --> <object class="GtkDialog" id="subscription_request_dialog"> <property name="border_width">5</property> <property name="title" translatable="yes">Subscription Request</property> <property name="role">subscription_request</property> <property name="resizable">False</property> - <property name="window_position">GTK_WIN_POS_CENTER_ON_PARENT</property> - <property name="type_hint">GDK_WINDOW_TYPE_HINT_DIALOG</property> + <property name="window_position">center-on-parent</property> + <property name="type_hint">dialog</property> <child internal-child="vbox"> <object class="GtkVBox" id="dialog-vbox4"> <property name="visible">True</property> @@ -22,11 +23,12 @@ <property name="visible">True</property> <property name="yalign">0</property> <property name="stock">gtk-dialog-question</property> - <property name="icon_size">6</property> + <property name="icon-size">6</property> </object> <packing> <property name="expand">False</property> <property name="fill">False</property> + <property name="position">0</property> </packing> </child> <child> @@ -40,50 +42,77 @@ <child internal-child="action_area"> <object class="GtkHButtonBox" id="dialog-action_area4"> <property name="visible">True</property> - <property name="layout_style">GTK_BUTTONBOX_END</property> + <property name="layout_style">end</property> + <child> + <object class="GtkButton" id="block-user-button"> + <property name="label" translatable="yes">_Block User</property> + <property name="can_focus">True</property> + <property name="receives_default">True</property> + <property name="use_underline">True</property> + </object> + <packing> + <property name="expand">False</property> + <property name="fill">False</property> + <property name="position">0</property> + </packing> + </child> <child> <object class="GtkButton" id="button19"> + <property name="label" translatable="yes">Decide _Later</property> <property name="visible">True</property> <property name="can_focus">True</property> <property name="can_default">True</property> - <property name="label" translatable="yes">Decide _Later</property> + <property name="receives_default">False</property> <property name="use_underline">True</property> </object> + <packing> + <property name="expand">False</property> + <property name="fill">False</property> + <property name="position">1</property> + </packing> </child> <child> <object class="GtkButton" id="button20"> + <property name="label">gtk-no</property> <property name="visible">True</property> <property name="can_focus">True</property> <property name="can_default">True</property> - <property name="label">gtk-no</property> + <property name="receives_default">False</property> <property name="use_stock">True</property> </object> <packing> - <property name="position">1</property> + <property name="expand">False</property> + <property name="fill">False</property> + <property name="position">2</property> </packing> </child> <child> <object class="GtkButton" id="button21"> + <property name="label">gtk-yes</property> <property name="visible">True</property> <property name="can_focus">True</property> <property name="can_default">True</property> <property name="has_default">True</property> - <property name="label">gtk-yes</property> + <property name="receives_default">False</property> <property name="use_stock">True</property> </object> <packing> - <property name="position">2</property> + <property name="expand">False</property> + <property name="fill">False</property> + <property name="position">3</property> </packing> </child> </object> <packing> <property name="expand">False</property> - <property name="pack_type">GTK_PACK_END</property> + <property name="pack_type">end</property> + <property name="position">0</property> </packing> </child> </object> </child> <action-widgets> + <action-widget response="-2">block-user-button</action-widget> <action-widget response="-6">button19</action-widget> <action-widget response="-9">button20</action-widget> <action-widget response="-8">button21</action-widget> diff --git a/libempathy-gtk/empathy-contact-menu.c b/libempathy-gtk/empathy-contact-menu.c index 3bf415746..9f36cf552 100644 --- a/libempathy-gtk/empathy-contact-menu.c +++ b/libempathy-gtk/empathy-contact-menu.c @@ -40,6 +40,8 @@ #include "empathy-ui-utils.h" #include "empathy-share-my-desktop.h" +static GtkWidget *empathy_contact_block_menu_item_new (EmpathyContact *); + GtkWidget * empathy_contact_menu_new (EmpathyContact *contact, EmpathyContactFeatureFlags features) @@ -139,6 +141,19 @@ empathy_contact_menu_new (EmpathyContact *contact, gtk_widget_show (item); } + /* Separator & Block */ + if (features & EMPATHY_CONTACT_FEATURE_BLOCK && + (item = empathy_contact_block_menu_item_new (contact)) != NULL) { + GtkWidget *sep; + + sep = gtk_separator_menu_item_new (); + gtk_menu_shell_append (shell, sep); + gtk_widget_show (sep); + + gtk_menu_shell_append (shell, item); + gtk_widget_show (item); + } + return menu; } @@ -214,6 +229,85 @@ empathy_contact_add_menu_item_new (EmpathyContact *contact) } static void +empathy_contact_block_menu_item_toggled (GtkCheckMenuItem *item, + EmpathyContact *contact) +{ + static guint block_signal = 0; + EmpathyContactManager *manager; + gboolean blocked, abusive; + + if (block_signal > 0) + return; + + blocked = gtk_check_menu_item_get_active (item); + + if (blocked) { + /* confirm the user really wishes to block the contact */ + GtkWidget *parent; + + /* gtk_menu_get_attach_widget() doesn't behave properly here + * for some reason */ + parent = g_object_get_data ( + G_OBJECT (gtk_widget_get_parent (GTK_WIDGET (item))), + "window"); + + if (!empathy_block_contact_dialog_show (GTK_WINDOW (parent), + contact, &abusive)) + return; + } + + manager = empathy_contact_manager_dup_singleton (); + empathy_contact_list_set_blocked (EMPATHY_CONTACT_LIST (manager), + contact, blocked, abusive); + g_object_unref (manager); + + /* update the toggle with the blocked status */ + block_signal++; + gtk_check_menu_item_set_active (item, blocked); + block_signal--; +} + +static GtkWidget * +empathy_contact_block_menu_item_new (EmpathyContact *contact) +{ + GtkWidget *item; + EmpathyContactManager *manager; + TpConnection *connection; + EmpathyContactListFlags flags; + gboolean blocked; + + g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL); + + manager = empathy_contact_manager_dup_singleton (); + + if (!empathy_contact_manager_initialized ()) { + return NULL; + } + + connection = empathy_contact_get_connection (contact); + + flags = empathy_contact_manager_get_flags_for_connection (manager, + connection); + + if (!(flags & EMPATHY_CONTACT_LIST_CAN_BLOCK)) { + return NULL; + } + + item = gtk_check_menu_item_new_with_mnemonic (_("_Block Contact")); + blocked = empathy_contact_list_get_blocked ( + EMPATHY_CONTACT_LIST (manager), + contact); + + gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), blocked); + + g_signal_connect (item, "toggled", + G_CALLBACK (empathy_contact_block_menu_item_toggled), + contact); + + return item; +} + +static void empathy_contact_chat_menu_item_activated (GtkMenuItem *item, EmpathyContact *contact) { diff --git a/libempathy-gtk/empathy-contact-menu.h b/libempathy-gtk/empathy-contact-menu.h index 2e0247420..35d6479e6 100644 --- a/libempathy-gtk/empathy-contact-menu.h +++ b/libempathy-gtk/empathy-contact-menu.h @@ -37,7 +37,8 @@ typedef enum { EMPATHY_CONTACT_FEATURE_INFO = 1 << 4, EMPATHY_CONTACT_FEATURE_FAVOURITE = 1 << 5, EMPATHY_CONTACT_FEATURE_FT = 1 << 6, - EMPATHY_CONTACT_FEATURE_ALL = (1 << 7) - 1, + EMPATHY_CONTACT_FEATURE_BLOCK = 1 << 7, + EMPATHY_CONTACT_FEATURE_ALL = (1 << 8) - 1, } EmpathyContactFeatureFlags; GtkWidget * empathy_contact_menu_new (EmpathyContact *contact, diff --git a/libempathy-gtk/empathy-individual-dialogs.c b/libempathy-gtk/empathy-individual-dialogs.c index 2c9801059..67ec22164 100644 --- a/libempathy-gtk/empathy-individual-dialogs.c +++ b/libempathy-gtk/empathy-individual-dialogs.c @@ -29,14 +29,18 @@ #include <telepathy-glib/util.h> #include <folks/folks.h> +#include <folks/folks-telepathy.h> #include <libempathy/empathy-individual-manager.h> #include <libempathy/empathy-utils.h> +#include <libempathy/empathy-contact-manager.h> #include "empathy-individual-dialogs.h" #include "empathy-contact-widget.h" #include "empathy-ui-utils.h" +#define BULLET_POINT "\342\200\242" + static GtkWidget *new_individual_dialog = NULL; /* @@ -156,3 +160,138 @@ empathy_new_individual_dialog_show_with_individual (GtkWindow *parent, tp_clear_object (&contact); } + +static char * +contact_pretty_name (TpContact *contact) +{ + const char *alias = tp_contact_get_alias (contact); + const char *identifier = tp_contact_get_identifier (contact); + + if (tp_strdiff (alias, identifier)) + return g_strdup_printf ("%s (%s)", alias, identifier); + else + return g_strdup (alias); +} + +/* + * Block contact dialog + */ +gboolean +empathy_block_individual_dialog_show (GtkWindow *parent, + FolksIndividual *individual, + gboolean *abusive) +{ + EmpathyContactManager *contact_manager = + empathy_contact_manager_dup_singleton (); + GtkWidget *dialog; + GtkWidget *abusive_check = NULL; + GList *personas, *l; + GString *text = g_string_new (""); + GString *blocked_str = g_string_new (""); + GString *notblocked_str = g_string_new (""); + guint npersonas_blocked = 0, npersonas_notblocked = 0; + gboolean can_report_abuse = FALSE; + int res; + + dialog = gtk_message_dialog_new (parent, + GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, + _("Block %s?"), + folks_aliasable_get_alias (FOLKS_ALIASABLE (individual))); + + /* build a list of personas that support blocking */ + personas = folks_individual_get_personas (individual); + + for (l = personas; l != NULL; l = l->next) + { + TpfPersona *persona = l->data; + TpContact *contact; + EmpathyContactListFlags flags; + GString *s; + char *str; + + if (!TPF_IS_PERSONA (persona)) + continue; + + contact = tpf_persona_get_contact (persona); + flags = empathy_contact_manager_get_flags_for_connection ( + contact_manager, tp_contact_get_connection (contact)); + + if (flags & EMPATHY_CONTACT_LIST_CAN_BLOCK) + { + s = blocked_str; + npersonas_blocked++; + } + else + { + s = notblocked_str; + npersonas_notblocked++; + } + + if (flags & EMPATHY_CONTACT_LIST_CAN_REPORT_ABUSIVE) + can_report_abuse = TRUE; + + str = contact_pretty_name (contact); + g_string_append_printf (s, "\n " BULLET_POINT " %s", str); + g_free (str); + } + + g_string_append_printf (text, + _("Are you sure you want to block '%s' from contacting you again?"), + folks_aliasable_get_alias (FOLKS_ALIASABLE (individual))); + + if (npersonas_blocked > 0) + g_string_append_printf (text, "\n\n%s\n%s", + ngettext ("The following identity will be blocked:", + "The following identities will be blocked:", + npersonas_blocked), + blocked_str->str); + + if (npersonas_notblocked > 0) + g_string_append_printf (text, "\n\n%s\n%s", + ngettext ("The following identity can not be blocked:", + "The following identities can not be blocked:", + npersonas_notblocked), + notblocked_str->str); + + gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), + "%s", text->str); + + gtk_dialog_add_buttons (GTK_DIALOG (dialog), + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + _("_Block"), GTK_RESPONSE_REJECT, + NULL); + + if (can_report_abuse) + { + GtkWidget *vbox; + + vbox = gtk_message_dialog_get_message_area (GTK_MESSAGE_DIALOG (dialog)); + abusive_check = gtk_check_button_new_with_mnemonic ( + ngettext ("_Report this contact as abusive", + "_Report these contacts as abusive", + npersonas_blocked)); + + gtk_box_pack_start (GTK_BOX (vbox), abusive_check, FALSE, TRUE, 0); + gtk_widget_show (abusive_check); + } + + g_object_unref (contact_manager); + g_string_free (text, TRUE); + g_string_free (blocked_str, TRUE); + g_string_free (notblocked_str, TRUE); + + res = gtk_dialog_run (GTK_DIALOG (dialog)); + + if (abusive != NULL) + { + if (abusive_check != NULL) + *abusive = gtk_toggle_button_get_active ( + GTK_TOGGLE_BUTTON (abusive_check)); + else + *abusive = FALSE; + } + + gtk_widget_destroy (dialog); + + return res == GTK_RESPONSE_REJECT; +} diff --git a/libempathy-gtk/empathy-individual-dialogs.h b/libempathy-gtk/empathy-individual-dialogs.h index b34a7ab18..1444d5ac8 100644 --- a/libempathy-gtk/empathy-individual-dialogs.h +++ b/libempathy-gtk/empathy-individual-dialogs.h @@ -32,6 +32,9 @@ G_BEGIN_DECLS void empathy_new_individual_dialog_show (GtkWindow *parent); void empathy_new_individual_dialog_show_with_individual (GtkWindow *parent, FolksIndividual *individual); +gboolean empathy_block_individual_dialog_show (GtkWindow *parent, + FolksIndividual *individual, + gboolean *abusive); G_END_DECLS diff --git a/libempathy-gtk/empathy-individual-view.c b/libempathy-gtk/empathy-individual-view.c index 9be022139..172b1facd 100644 --- a/libempathy-gtk/empathy-individual-view.c +++ b/libempathy-gtk/empathy-individual-view.c @@ -47,6 +47,7 @@ #include "empathy-individual-menu.h" #include "empathy-individual-store.h" #include "empathy-contact-dialogs.h" +#include "empathy-individual-dialogs.h" #include "empathy-images.h" #include "empathy-linking-dialog.h" #include "empathy-cell-renderer-expander.h" @@ -2269,16 +2270,22 @@ empathy_individual_view_dup_selected_group (EmpathyIndividualView *view, return name; } -static gboolean +static int individual_view_remove_dialog_show (GtkWindow *parent, const gchar *message, - const gchar *secondary_text) + const gchar *secondary_text, + gboolean block_button) { GtkWidget *dialog; gboolean res; dialog = gtk_message_dialog_new (parent, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "%s", message); + + if (block_button) + gtk_dialog_add_button (GTK_DIALOG (dialog), + _("Delete and Block"), GTK_RESPONSE_REJECT); + gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_NO, GTK_STOCK_DELETE, GTK_RESPONSE_YES, NULL); @@ -2290,7 +2297,7 @@ individual_view_remove_dialog_show (GtkWindow *parent, res = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); - return (res == GTK_RESPONSE_YES); + return res; } static void @@ -2310,7 +2317,7 @@ individual_view_group_remove_activate_cb (GtkMenuItem *menuitem, group); parent = empathy_get_toplevel_window (GTK_WIDGET (view)); if (individual_view_remove_dialog_show (parent, _("Removing group"), - text)) + text, FALSE) == GTK_RESPONSE_YES) { EmpathyIndividualManager *manager = empathy_individual_manager_dup_singleton (); @@ -2389,10 +2396,13 @@ individual_view_remove_activate_cb (GtkMenuItem *menuitem, if (individual != NULL) { + EmpathyIndividualManager *manager; gchar *text; GtkWindow *parent; GList *l, *personas; guint persona_count = 0; + gboolean can_block; + int res; personas = folks_individual_get_personas (individual); @@ -2428,20 +2438,37 @@ individual_view_remove_activate_cb (GtkMenuItem *menuitem, folks_aliasable_get_alias (FOLKS_ALIASABLE (individual))); } + + manager = empathy_individual_manager_dup_singleton (); + can_block = empathy_individual_manager_supports_blocking (manager, + individual); parent = empathy_get_toplevel_window (GTK_WIDGET (view)); + res = individual_view_remove_dialog_show (parent, _("Removing contact"), + text, can_block); - if (individual_view_remove_dialog_show (parent, _("Removing contact"), - text)) + if (res == GTK_RESPONSE_YES || res == GTK_RESPONSE_REJECT) { - EmpathyIndividualManager *manager; + gboolean abusive; + + if (res == GTK_RESPONSE_REJECT && + empathy_block_individual_dialog_show (parent, individual, + &abusive)) + { + empathy_individual_manager_set_blocked (manager, individual, + TRUE, abusive); + } + else + { + goto finally; + } - manager = empathy_individual_manager_dup_singleton (); empathy_individual_manager_remove (manager, individual, ""); - g_object_unref (G_OBJECT (manager)); } +finally: g_free (text); g_object_unref (individual); + g_object_unref (manager); } } diff --git a/libempathy/empathy-contact-list.c b/libempathy/empathy-contact-list.c index 631bb4a37..d28866735 100644 --- a/libempathy/empathy-contact-list.c +++ b/libempathy/empathy-contact-list.c @@ -278,3 +278,27 @@ empathy_contact_list_remove_from_favourites (EmpathyContactList *list, contact); } } + +void +empathy_contact_list_set_blocked (EmpathyContactList *list, + EmpathyContact *contact, + gboolean blocked, + gboolean abusive) +{ + EmpathyContactListIface *iface = EMPATHY_CONTACT_LIST_GET_IFACE (list); + + if (iface->set_blocked != NULL) + iface->set_blocked (list, contact, blocked, abusive); +} + +gboolean +empathy_contact_list_get_blocked (EmpathyContactList *list, + EmpathyContact *contact) +{ + EmpathyContactListIface *iface = EMPATHY_CONTACT_LIST_GET_IFACE (list); + + if (iface->get_blocked != NULL) + return iface->get_blocked (list, contact); + else + return FALSE; +} diff --git a/libempathy/empathy-contact-list.h b/libempathy/empathy-contact-list.h index 3817af876..cf523bf2a 100644 --- a/libempathy/empathy-contact-list.h +++ b/libempathy/empathy-contact-list.h @@ -39,6 +39,8 @@ typedef enum { EMPATHY_CONTACT_LIST_CAN_REMOVE = 1 << 1, EMPATHY_CONTACT_LIST_CAN_ALIAS = 1 << 2, EMPATHY_CONTACT_LIST_CAN_GROUP = 1 << 3, + EMPATHY_CONTACT_LIST_CAN_BLOCK = 1 << 4, + EMPATHY_CONTACT_LIST_CAN_REPORT_ABUSIVE = 1 << 5, } EmpathyContactListFlags; typedef struct _EmpathyContactListIface EmpathyContactListIface; @@ -77,6 +79,12 @@ struct _EmpathyContactListIface { EmpathyContact *contact); void (*remove_favourite) (EmpathyContactList *list, EmpathyContact *contact); + void (*set_blocked) (EmpathyContactList *list, + EmpathyContact *contact, + gboolean blocked, + gboolean abusive); + gboolean (*get_blocked) (EmpathyContactList *list, + EmpathyContact *contact); }; GType empathy_contact_list_get_type (void) G_GNUC_CONST; @@ -116,6 +124,13 @@ void empathy_contact_list_remove_from_favourites (EmpathyContactList *list, EmpathyContact *contact); +void empathy_contact_list_set_blocked (EmpathyContactList *list, + EmpathyContact *contact, + gboolean blocked, + gboolean abusive); +gboolean empathy_contact_list_get_blocked (EmpathyContactList *list, + EmpathyContact *contact); + G_END_DECLS diff --git a/libempathy/empathy-contact-manager.c b/libempathy/empathy-contact-manager.c index a900fa610..b00f82477 100644 --- a/libempathy/empathy-contact-manager.c +++ b/libempathy/empathy-contact-manager.c @@ -865,6 +865,47 @@ contact_manager_remove_group (EmpathyContactList *manager, } static void +contact_manager_set_blocked (EmpathyContactList *manager, + EmpathyContact *contact, + gboolean blocked, + gboolean abusive) +{ + EmpathyContactManagerPriv *priv = GET_PRIV (manager); + EmpathyContactList *list; + TpConnection *connection; + + g_return_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager)); + + connection = empathy_contact_get_connection (contact); + list = g_hash_table_lookup (priv->lists, connection); + + if (list != NULL) { + empathy_contact_list_set_blocked (list, contact, + blocked, abusive); + } +} + +static gboolean +contact_manager_get_blocked (EmpathyContactList *manager, + EmpathyContact *contact) +{ + EmpathyContactManagerPriv *priv = GET_PRIV (manager); + EmpathyContactList *list; + TpConnection *connection; + + g_return_val_if_fail (EMPATHY_IS_CONTACT_MANAGER (manager), FALSE); + + connection = empathy_contact_get_connection (contact); + list = g_hash_table_lookup (priv->lists, connection); + + if (list != NULL) { + return empathy_contact_list_get_blocked (list, contact); + } else { + return FALSE; + } +} + +static void contact_manager_iface_init (EmpathyContactListIface *iface) { iface->add = contact_manager_add; @@ -880,6 +921,8 @@ contact_manager_iface_init (EmpathyContactListIface *iface) iface->is_favourite = contact_manager_is_favourite; iface->remove_favourite = contact_manager_remove_favourite; iface->add_favourite = contact_manager_add_favourite; + iface->set_blocked = contact_manager_set_blocked; + iface->get_blocked = contact_manager_get_blocked; } EmpathyContactListFlags diff --git a/libempathy/empathy-individual-manager.c b/libempathy/empathy-individual-manager.c index 894ae648b..137d00f1f 100644 --- a/libempathy/empathy-individual-manager.c +++ b/libempathy/empathy-individual-manager.c @@ -30,12 +30,14 @@ #include <telepathy-glib/util.h> #include <folks/folks.h> +#include <folks/folks-telepathy.h> #include <extensions/extensions.h> #include "empathy-individual-manager.h" #include "empathy-marshal.h" #include "empathy-utils.h" +#include "empathy-contact-manager.h" #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT #include "empathy-debug.h" @@ -483,6 +485,89 @@ empathy_individual_manager_remove (EmpathyIndividualManager *self, aggregator_remove_individual_cb, self); } +/* FIXME: The parameter @self is not required and the method can be placed in + * utilities. I left it as it is to stay coherent with empathy-2.34 */ +/** + * empathy_individual_manager_supports_blocking + * @self: the #EmpathyIndividualManager + * @individual: an individual to check + * + * Indicates whether any personas of an @individual can be blocked. + * + * Returns: %TRUE if any persona supports contact blocking + */ +gboolean +empathy_individual_manager_supports_blocking (EmpathyIndividualManager *self, + FolksIndividual *individual) +{ + EmpathyIndividualManagerPriv *priv; + GList *personas, *l; + + g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self), FALSE); + + priv = GET_PRIV (self); + + personas = folks_individual_get_personas (individual); + + for (l = personas; l != NULL; l = l->next) + { + TpfPersona *persona = l->data; + TpConnection *conn; + EmpathyContactManager *manager; + + if (!TPF_IS_PERSONA (persona)) + continue; + + conn = tp_contact_get_connection (tpf_persona_get_contact (persona)); + manager = empathy_contact_manager_dup_singleton (); + + if (empathy_contact_manager_get_flags_for_connection (manager, conn) & + EMPATHY_CONTACT_LIST_CAN_BLOCK) + return TRUE; + + g_object_unref (manager); + } + + return FALSE; +} + +void +empathy_individual_manager_set_blocked (EmpathyIndividualManager *self, + FolksIndividual *individual, + gboolean blocked, + gboolean abusive) +{ + EmpathyIndividualManagerPriv *priv; + GList *personas, *l; + + g_return_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self)); + + priv = GET_PRIV (self); + + personas = folks_individual_get_personas (individual); + + for (l = personas; l != NULL; l = l->next) + { + TpfPersona *persona = l->data; + EmpathyContact *contact; + EmpathyContactManager *manager; + + if (!TPF_IS_PERSONA (persona)) + continue; + + contact = empathy_contact_dup_from_tp_contact ( + tpf_persona_get_contact (persona)); + empathy_contact_set_persona (contact, FOLKS_PERSONA (persona)); + manager = empathy_contact_manager_dup_singleton (); + empathy_contact_list_set_blocked ( + EMPATHY_CONTACT_LIST (manager), + contact, blocked, abusive); + + g_object_unref (manager); + g_object_unref (contact); + } +} + static void groups_change_group_cb (GObject *source, GAsyncResult *result, diff --git a/libempathy/empathy-individual-manager.h b/libempathy/empathy-individual-manager.h index f2f5f5b56..1fec67d91 100644 --- a/libempathy/empathy-individual-manager.h +++ b/libempathy/empathy-individual-manager.h @@ -81,5 +81,14 @@ void empathy_individual_manager_unlink_individual ( EmpathyIndividualManager *self, FolksIndividual *individual); +gboolean empathy_individual_manager_supports_blocking ( + EmpathyIndividualManager *self, + FolksIndividual *individual); + +void empathy_individual_manager_set_blocked (EmpathyIndividualManager *self, + FolksIndividual *individual, + gboolean blocked, + gboolean abusive); + G_END_DECLS #endif /* __EMPATHY_INDIVIDUAL_MANAGER_H__ */ diff --git a/libempathy/empathy-tp-contact-list.c b/libempathy/empathy-tp-contact-list.c index 263c379f6..90932a20a 100644 --- a/libempathy/empathy-tp-contact-list.c +++ b/libempathy/empathy-tp-contact-list.c @@ -31,6 +31,8 @@ #include <telepathy-glib/dbus.h> #include <telepathy-glib/interfaces.h> +#include <extensions/extensions.h> + #include "empathy-tp-contact-list.h" #include "empathy-tp-contact-factory.h" #include "empathy-contact-list.h" @@ -46,6 +48,7 @@ typedef struct { TpChannel *publish; TpChannel *subscribe; TpChannel *stored; + TpChannel *deny; /* contact handle (TpHandle) => reffed (EmpathyContact *) * * Union of: @@ -722,6 +725,10 @@ tp_contact_list_finalize (GObject *object) g_object_unref (priv->stored); } + if (priv->deny) { + g_object_unref (priv->deny); + } + if (priv->connection) { g_object_unref (priv->connection); } @@ -773,6 +780,11 @@ got_list_channel (EmpathyTpContactList *list, g_signal_connect (priv->subscribe, "group-members-changed", G_CALLBACK (tp_contact_list_subscribe_group_members_changed_cb), list); + } else if (!tp_strdiff (id, "deny")) { + if (priv->deny != NULL) + return; + DEBUG ("Got 'deny' channel"); + priv->deny = g_object_ref (channel); } } @@ -799,6 +811,27 @@ list_ensure_channel_cb (TpConnection *conn, } static void +list_get_contact_blocking_capabilities_cb (TpProxy *conn, + const GValue *value, + const GError *in_error, + gpointer user_data, + GObject *weak_object) +{ + EmpathyTpContactList *list = EMPATHY_TP_CONTACT_LIST (weak_object); + EmpathyTpContactListPriv *priv = GET_PRIV (list); + EmpContactBlockingCapabilities caps; + + g_return_if_fail (G_VALUE_HOLDS_UINT (value)); + + caps = g_value_get_uint (value); + + if (caps & EMP_CONTACT_BLOCKING_CAPABILITY_CAN_REPORT_ABUSIVE) { + DEBUG ("Connection can report abusive contacts"); + priv->flags |= EMPATHY_CONTACT_LIST_CAN_REPORT_ABUSIVE; + } +} + +static void iterate_on_channels (EmpathyTpContactList *list, const GPtrArray *channels) { @@ -881,8 +914,8 @@ conn_ready_cb (TpConnection *connection, NULL, NULL, G_OBJECT (list)); request = tp_asv_new ( - TP_IFACE_CHANNEL ".ChannelType", G_TYPE_STRING, TP_IFACE_CHANNEL_TYPE_CONTACT_LIST, - TP_IFACE_CHANNEL ".TargetHandleType", G_TYPE_UINT, TP_HANDLE_TYPE_LIST, + TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING, TP_IFACE_CHANNEL_TYPE_CONTACT_LIST, + TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT, TP_HANDLE_TYPE_LIST, NULL); /* Watch the NewChannels signal so if ensuring list channels fails (for @@ -892,21 +925,39 @@ conn_ready_cb (TpConnection *connection, priv->connection, new_channels_cb, NULL, NULL, G_OBJECT (list), NULL); /* Request the 'stored' list. */ - tp_asv_set_static_string (request, TP_IFACE_CHANNEL ".TargetID", "stored"); + tp_asv_set_static_string (request, TP_PROP_CHANNEL_TARGET_ID, "stored"); tp_cli_connection_interface_requests_call_ensure_channel (priv->connection, G_MAXINT, request, list_ensure_channel_cb, list, NULL, G_OBJECT (list)); /* Request the 'publish' list. */ - tp_asv_set_static_string (request, TP_IFACE_CHANNEL ".TargetID", "publish"); + tp_asv_set_static_string (request, TP_PROP_CHANNEL_TARGET_ID, "publish"); tp_cli_connection_interface_requests_call_ensure_channel (priv->connection, G_MAXINT, request, list_ensure_channel_cb, list, NULL, G_OBJECT (list)); /* Request the 'subscribe' list. */ - tp_asv_set_static_string (request, TP_IFACE_CHANNEL ".TargetID", "subscribe"); + tp_asv_set_static_string (request, TP_PROP_CHANNEL_TARGET_ID, "subscribe"); + tp_cli_connection_interface_requests_call_ensure_channel (priv->connection, + G_MAXINT, request, list_ensure_channel_cb, list, NULL, G_OBJECT (list)); + + /* Request the 'deny' list */ + tp_asv_set_static_string (request, TP_PROP_CHANNEL_TARGET_ID, "deny"); tp_cli_connection_interface_requests_call_ensure_channel (priv->connection, G_MAXINT, request, list_ensure_channel_cb, list, NULL, G_OBJECT (list)); g_hash_table_unref (request); + + /* Find out if we support reporting abusive contacts -- + * this is done via the new Conn.I.ContactBlocking interface */ + if (tp_proxy_has_interface_by_id (priv->connection, + EMP_IFACE_QUARK_CONNECTION_INTERFACE_CONTACT_BLOCKING)) { + DEBUG ("Have Conn.I.ContactBlocking"); + + tp_cli_dbus_properties_call_get (priv->connection, -1, + EMP_IFACE_CONNECTION_INTERFACE_CONTACT_BLOCKING, + "ContactBlockingCapabilities", + list_get_contact_blocking_capabilities_cb, + NULL, NULL, G_OBJECT (list)); + } out: g_object_unref (list); } @@ -1289,10 +1340,56 @@ tp_contact_list_get_flags (EmpathyContactList *list) } } + if (priv->deny != NULL) + flags |= EMPATHY_CONTACT_LIST_CAN_BLOCK; + return flags; } static void +tp_contact_list_set_blocked (EmpathyContactList *list, + EmpathyContact *contact, + gboolean blocked, + gboolean abusive) +{ + EmpathyTpContactListPriv *priv = GET_PRIV (list); + TpHandle handle = empathy_contact_get_handle (contact); + GArray handles = { (char *) &handle, 1 }; + + g_return_if_fail (TP_IS_CHANNEL (priv->deny)); + + if (blocked && abusive) { + /* we have to do this via the new interface */ + g_return_if_fail (priv->flags & + EMPATHY_CONTACT_LIST_CAN_REPORT_ABUSIVE); + + emp_cli_connection_interface_contact_blocking_call_block_contacts ( + TP_PROXY (priv->connection), -1, + &handles, TRUE, NULL, NULL, NULL, NULL); + } else if (blocked) { + tp_cli_channel_interface_group_call_add_members ( + priv->deny, -1, + &handles, NULL, NULL, NULL, NULL, NULL); + } else { + tp_cli_channel_interface_group_call_remove_members ( + priv->deny, -1, + &handles, NULL, NULL, NULL, NULL, NULL); + } +} + +static gboolean +tp_contact_list_get_blocked (EmpathyContactList *list, + EmpathyContact *contact) +{ + EmpathyTpContactListPriv *priv = GET_PRIV (list); + + g_return_val_if_fail (TP_IS_CHANNEL (priv->deny), FALSE); + + return tp_intset_is_member (tp_channel_group_get_members (priv->deny), + empathy_contact_get_handle (contact)); +} + +static void tp_contact_list_iface_init (EmpathyContactListIface *iface) { iface->add = tp_contact_list_add; @@ -1306,6 +1403,8 @@ tp_contact_list_iface_init (EmpathyContactListIface *iface) iface->rename_group = tp_contact_list_rename_group; iface->remove_group = tp_contact_list_remove_group; iface->get_flags = tp_contact_list_get_flags; + iface->set_blocked = tp_contact_list_set_blocked; + iface->get_blocked = tp_contact_list_get_blocked; } void @@ -1334,4 +1433,3 @@ empathy_tp_contact_list_remove_all (EmpathyTpContactList *list) } g_hash_table_remove_all (priv->pendings); } - diff --git a/libempathy/empathy-tp-contact-list.h b/libempathy/empathy-tp-contact-list.h index 071fc0b91..9a555bc7a 100644 --- a/libempathy/empathy-tp-contact-list.h +++ b/libempathy/empathy-tp-contact-list.h @@ -26,6 +26,7 @@ #include <glib.h> #include <telepathy-glib/connection.h> +#include <libempathy/empathy-contact.h> G_BEGIN_DECLS diff --git a/src/empathy-chat-window.c b/src/empathy-chat-window.c index 799a8254d..23c93a15b 100644 --- a/src/empathy-chat-window.c +++ b/src/empathy-chat-window.c @@ -417,12 +417,15 @@ chat_window_contact_menu_update (EmpathyChatWindowPriv *priv, if (orig_submenu == NULL || !gtk_widget_get_visible (orig_submenu)) { submenu = empathy_chat_get_contact_menu (priv->current_chat); + if (submenu != NULL) { + /* gtk_menu_attach_to_widget() doesn't behave nicely here */ + g_object_set_data (G_OBJECT (submenu), "window", priv->dialog); + gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu), submenu); gtk_widget_show (menu); gtk_widget_set_sensitive (menu, TRUE); - } - else { + } else { gtk_widget_set_sensitive (menu, FALSE); } } else { diff --git a/src/empathy-main-window.c b/src/empathy-main-window.c index 8f08f74be..12b99ba5f 100644 --- a/src/empathy-main-window.c +++ b/src/empathy-main-window.c @@ -50,6 +50,7 @@ #include <libempathy-gtk/empathy-contact-list-store.h> #include <libempathy-gtk/empathy-contact-list-view.h> #include <libempathy-gtk/empathy-live-search.h> +#include <libempathy-gtk/empathy-contact-blocking-dialog.h> #include <libempathy-gtk/empathy-contact-search-dialog.h> #include <libempathy-gtk/empathy-geometry.h> #include <libempathy-gtk/empathy-gtk-enum-types.h> @@ -1464,6 +1465,18 @@ main_window_edit_personal_information_cb (GtkAction *action, } static void +main_window_edit_blocked_contacts_cb (GtkAction *action, + EmpathyMainWindow *window) +{ + GtkWidget *dialog; + + dialog = empathy_contact_blocking_dialog_new (GTK_WINDOW (window)); + gtk_widget_show (dialog); + g_signal_connect (dialog, "response", + G_CALLBACK (gtk_widget_destroy), NULL); +} + +static void main_window_edit_preferences_cb (GtkAction *action, EmpathyMainWindow *window) { @@ -1622,7 +1635,8 @@ main_window_connection_items_setup (EmpathyMainWindow *window, "chat_new_message", "chat_new_call", "chat_add_contact", - "edit_personal_information" + "edit_personal_information", + "edit_blocked_contacts" }; for (i = 0, list = NULL; i < G_N_ELEMENTS (actions_connected); i++) { @@ -1801,6 +1815,7 @@ empathy_main_window_init (EmpathyMainWindow *window) "edit", "activate", main_window_edit_cb, "edit_accounts", "activate", main_window_edit_accounts_cb, "edit_personal_information", "activate", main_window_edit_personal_information_cb, + "edit_blocked_contacts", "activate", main_window_edit_blocked_contacts_cb, "edit_preferences", "activate", main_window_edit_preferences_cb, "edit_search_contacts", "activate", main_window_edit_search_contacts_cb, "help_about", "activate", main_window_help_about_cb, diff --git a/src/empathy-main-window.ui b/src/empathy-main-window.ui index 0cfd6bee4..217b276f2 100644 --- a/src/empathy-main-window.ui +++ b/src/empathy-main-window.ui @@ -107,6 +107,12 @@ </object> </child> <child> + <object class="GtkAction" id="edit_blocked_contacts"> + <property name="name">edit_blocked_contacts</property> + <property name="label" translatable="yes">_Blocked Contacts</property> + </object> + </child> + <child> <object class="GtkAction" id="edit_preferences"> <property name="stock_id">gtk-preferences</property> <property name="name">edit_preferences</property> @@ -249,6 +255,7 @@ <menuitem action="edit_accounts"/> <menuitem action="edit_personal_information"/> <menuitem action="edit_search_contacts"/> + <menuitem action="edit_blocked_contacts"/> <separator/> <menuitem action="edit_preferences"/> </menu> diff --git a/tests/interactive/.gitignore b/tests/interactive/.gitignore index ebaa4d1e9..ea3271654 100644 --- a/tests/interactive/.gitignore +++ b/tests/interactive/.gitignore @@ -4,6 +4,7 @@ contact-run-until-ready contact-run-until-ready-2 empetit test-empathy-account-assistant +test-empathy-contact-blocking-dialog test-empathy-presence-chooser test-empathy-status-preset-dialog test-empathy-protocol-chooser diff --git a/tests/interactive/Makefile.am b/tests/interactive/Makefile.am index 24e674c6a..bf2e83929 100644 --- a/tests/interactive/Makefile.am +++ b/tests/interactive/Makefile.am @@ -18,6 +18,7 @@ noinst_PROGRAMS = \ empathy-logs \ empetit \ test-empathy-account-assistant \ + test-empathy-contact-blocking-dialog \ test-empathy-presence-chooser \ test-empathy-status-preset-dialog \ test-empathy-protocol-chooser \ @@ -26,6 +27,7 @@ noinst_PROGRAMS = \ contact_manager_SOURCES = contact-manager.c empathy_logs_SOURCES = empathy-logs.c empetit_SOURCES = empetit.c +test_empathy_contact_blocking_dialog_SOURCES = test-empathy-contact-blocking-dialog.c test_empathy_presence_chooser_SOURCES = test-empathy-presence-chooser.c test_empathy_status_preset_dialog_SOURCES = test-empathy-status-preset-dialog.c test_empathy_protocol_chooser_SOURCES = test-empathy-protocol-chooser.c diff --git a/tests/interactive/test-empathy-contact-blocking-dialog.c b/tests/interactive/test-empathy-contact-blocking-dialog.c new file mode 100644 index 000000000..6c5615ec3 --- /dev/null +++ b/tests/interactive/test-empathy-contact-blocking-dialog.c @@ -0,0 +1,55 @@ +/* + * Copyright (C) 2011 Collabora Ltd. + * + * 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., 59 Temple Place - Suite 330, + * Boston, MA 02111-1307, USA. + * + * Authors: Danielle Madeley <danielle.madeley@collabora.co.uk> + */ + +#include <config.h> + +#include <gtk/gtk.h> + +#include <libempathy/empathy-contact-manager.h> + +#include <libempathy-gtk/empathy-ui-utils.h> +#include <libempathy-gtk/empathy-contact-blocking-dialog.h> + +int +main (int argc, + char **argv) + { + EmpathyContactManager *manager; + GtkWidget *dialog; + + gtk_init (&argc, &argv); + empathy_gtk_init (); + + manager = empathy_contact_manager_dup_singleton (); + dialog = empathy_contact_blocking_dialog_new (NULL); + + g_signal_connect_swapped (dialog, "response", + G_CALLBACK (gtk_main_quit), NULL); + + gtk_widget_show (dialog); + + gtk_main (); + + gtk_widget_destroy (dialog); + g_object_unref (manager); + + return 0; + } |