static gint
sort_personas (FolksPersona *persona_a,
FolksPersona *persona_b)
{
EmpathyContact *contact;
TpAccount *account_a, *account_b;
gint ret_val;
g_return_val_if_fail (persona_a != NULL || persona_b != NULL, 0);
/* alias */
ret_val = g_utf8_collate (
folks_aliasable_get_alias (FOLKS_ALIASABLE (persona_a)),
folks_aliasable_get_alias (FOLKS_ALIASABLE (persona_b)));
if (ret_val != 0)
goto out;
/* identifier */
ret_val = g_utf8_collate (folks_persona_get_display_id (persona_a),
folks_persona_get_display_id (persona_b));
if (ret_val != 0)
goto out;
contact = empathy_contact_dup_from_tp_contact (tpf_persona_get_contact (
TPF_PERSONA (persona_a)));
account_a = empathy_contact_get_account (contact);
g_object_unref (contact);
contact = empathy_contact_dup_from_tp_contact (tpf_persona_get_contact (
TPF_PERSONA (persona_b)));
account_b = empathy_contact_get_account (contact);
g_object_unref (contact);
/* protocol */
ret_val = strcmp (tp_account_get_protocol (account_a),
tp_account_get_protocol (account_a));
if (ret_val != 0)
goto out;
/* account ID */
ret_val = strcmp (tp_proxy_get_object_path (account_a),
tp_proxy_get_object_path (account_a));
out:
return ret_val;
}
/* Return the TpContact on @conn associated with @individual, if any */
TpContact *
empathy_get_tp_contact_for_individual (FolksIndividual *individual,
TpConnection *conn)
{
TpContact *contact = NULL;
GeeSet *personas;
GeeIterator *iter;
personas = folks_individual_get_personas (individual);
iter = gee_iterable_iterator (GEE_ITERABLE (personas));
while (contact == NULL && gee_iterator_next (iter))
{
TpfPersona *persona = gee_iterator_get (iter);
TpConnection *contact_conn;
TpContact *contact_cur = NULL;
if (TPF_IS_PERSONA (persona))
{
contact_cur = tpf_persona_get_contact (persona);
if (contact_cur != NULL)
{
contact_conn = tp_contact_get_connection (contact_cur);
if (!tp_strdiff (tp_proxy_get_object_path (contact_conn),
tp_proxy_get_object_path (conn)))
contact = contact_cur;
}
}
g_clear_object (&persona);
}
g_clear_object (&iter);
return contact;
}
/* Returns TRUE if the given Individual contains a TpContact */
gboolean
empathy_folks_individual_contains_contact (FolksIndividual *individual)
{
GeeSet *personas;
GeeIterator *iter;
gboolean retval = FALSE;
g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), FALSE);
personas = folks_individual_get_personas (individual);
iter = gee_iterable_iterator (GEE_ITERABLE (personas));
while (!retval && gee_iterator_next (iter))
{
FolksPersona *persona = gee_iterator_get (iter);
TpContact *contact = NULL;
if (empathy_folks_persona_is_interesting (persona))
contact = tpf_persona_get_contact (TPF_PERSONA (persona));
g_clear_object (&persona);
if (contact != NULL)
retval = TRUE;
}
g_clear_object (&iter);
return retval;
}
static gboolean
individual_has_contact (FolksIndividual *individual,
TpContact *contact)
{
GeeSet *personas;
GeeIterator *iter;
gboolean found = FALSE;
personas = folks_individual_get_personas (individual);
iter = gee_iterable_iterator (GEE_ITERABLE (personas));
while (!found && gee_iterator_next (iter))
{
TpfPersona *persona = gee_iterator_get (iter);
if (TPF_IS_PERSONA (persona))
{
TpContact *c = tpf_persona_get_contact (persona);
if (c == contact)
found = TRUE;
}
g_clear_object (&persona);
}
g_clear_object (&iter);
return found;
}
/* Calculate whether the Individual can do audio or video calls.
* FIXME: We can remove this once libfolks has grown capabilities support
* again: bgo#626179. */
void
empathy_individual_can_audio_video_call (FolksIndividual *individual,
gboolean *can_audio_call,
gboolean *can_video_call,
EmpathyContact **out_contact)
{
GeeSet *personas;
GeeIterator *iter;
gboolean can_audio = FALSE, can_video = FALSE;
personas = folks_individual_get_personas (individual);
iter = gee_iterable_iterator (GEE_ITERABLE (personas));
while (gee_iterator_next (iter))
{
FolksPersona *persona = gee_iterator_get (iter);
TpContact *tp_contact;
if (!empathy_folks_persona_is_interesting (persona))
goto while_finish;
tp_contact = tpf_persona_get_contact (TPF_PERSONA (persona));
if (tp_contact != NULL)
{
EmpathyContact *contact;
contact = empathy_contact_dup_from_tp_contact (tp_contact);
empathy_contact_set_persona (contact, persona);
can_audio = can_audio || empathy_contact_get_capabilities (contact) &
EMPATHY_CAPABILITIES_AUDIO;
can_video = can_video || empathy_contact_get_capabilities (contact) &
EMPATHY_CAPABILITIES_VIDEO;
if (out_contact != NULL)
*out_contact = g_object_ref (contact);
g_object_unref (contact);
}
while_finish:
g_clear_object (&persona);
if (can_audio && can_video)
break;
}
g_clear_object (&iter);
if (can_audio_call != NULL)
*can_audio_call = can_audio;
if (can_video_call != NULL)
*can_video_call = can_video;
}
static GdkPixbuf *
get_persona_status_icon (EmpathyPersonaStore *self,
FolksPersona *persona)
{
EmpathyPersonaStorePriv *priv = GET_PRIV (self);
EmpathyContact *contact;
const gchar *protocol_name = NULL;
gchar *icon_name = NULL;
GdkPixbuf *pixbuf_status = NULL;
const gchar *status_icon_name = NULL;
contact = empathy_contact_dup_from_tp_contact (tpf_persona_get_contact (
TPF_PERSONA (persona)));
status_icon_name = empathy_icon_name_for_contact (contact);
if (status_icon_name == NULL)
{
g_object_unref (contact);
return NULL;
}
if (priv->show_protocols)
{
protocol_name = empathy_protocol_name_for_contact (contact);
icon_name = g_strdup_printf ("%s-%s", status_icon_name, protocol_name);
}
else
{
icon_name = g_strdup_printf ("%s", status_icon_name);
}
pixbuf_status = g_hash_table_lookup (priv->status_icons, icon_name);
if (pixbuf_status == NULL)
{
pixbuf_status = empathy_pixbuf_contact_status_icon_with_icon_name (
contact, status_icon_name, priv->show_protocols);
if (pixbuf_status != NULL)
{
g_hash_table_insert (priv->status_icons, g_strdup (icon_name),
pixbuf_status);
}
}
g_object_unref (contact);
g_free (icon_name);
return pixbuf_status;
}
static void
add_persona (EmpathyPersonaStore *self,
FolksPersona *persona)
{
EmpathyPersonaStorePriv *priv;
GtkTreeIter iter;
GtkTreePath *path;
FolksPersonaStore *store;
EmpathyContact *contact;
const gchar *alias;
if (!TPF_IS_PERSONA (persona))
return;
priv = GET_PRIV (self);
alias = folks_aliasable_get_alias (FOLKS_ALIASABLE (persona));
if (EMP_STR_EMPTY (alias))
return;
contact = empathy_contact_dup_from_tp_contact (tpf_persona_get_contact (
TPF_PERSONA (persona)));
store = folks_persona_get_store (persona);
gtk_list_store_insert_with_values (GTK_LIST_STORE (self), &iter, 0,
EMPATHY_PERSONA_STORE_COL_NAME, alias,
EMPATHY_PERSONA_STORE_COL_ACCOUNT_NAME,
folks_persona_store_get_display_name (store),
EMPATHY_PERSONA_STORE_COL_DISPLAY_ID,
folks_persona_get_display_id (persona),
EMPATHY_PERSONA_STORE_COL_PERSONA, persona,
EMPATHY_PERSONA_STORE_COL_CAN_AUDIO_CALL,
empathy_contact_get_capabilities (contact) &
EMPATHY_CAPABILITIES_AUDIO,
EMPATHY_PERSONA_STORE_COL_CAN_VIDEO_CALL,
empathy_contact_get_capabilities (contact) &
EMPATHY_CAPABILITIES_VIDEO,
-1);
g_object_unref (contact);
path = gtk_tree_model_get_path (GTK_TREE_MODEL (self), &iter);
g_hash_table_replace (priv->personas, g_object_ref (persona),
gtk_tree_row_reference_new (GTK_TREE_MODEL (self), path));
gtk_tree_path_free (path);
update_persona (self, persona);
}
void
empathy_individual_manager_set_blocked (EmpathyIndividualManager *self,
FolksIndividual *individual,
gboolean blocked,
gboolean abusive)
{
GeeSet *personas;
GeeIterator *iter;
g_return_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self));
personas = folks_individual_get_personas (individual);
iter = gee_iterable_iterator (GEE_ITERABLE (personas));
while (gee_iterator_next (iter))
{
TpfPersona *persona = gee_iterator_get (iter);
if (TPF_IS_PERSONA (persona))
{
TpContact *tp_contact;
TpConnection *conn;
tp_contact = tpf_persona_get_contact (persona);
if (tp_contact == NULL)
continue;
conn = tp_contact_get_connection (tp_contact);
if (!tp_proxy_has_interface_by_id (conn,
TP_IFACE_QUARK_CONNECTION_INTERFACE_CONTACT_BLOCKING))
continue;
if (blocked)
tp_contact_block_async (tp_contact, abusive, NULL, NULL);
else
tp_contact_unblock_async (tp_contact, NULL, NULL);
}
g_clear_object (&persona);
}
g_clear_object (&iter);
}
/* Retrieve the EmpathyContact corresponding to the first TpContact contained
* within the given Individual. Note that this is a temporary convenience. See
* the TODO above. */
EmpathyContact *
empathy_contact_dup_from_folks_individual (FolksIndividual *individual)
{
GeeSet *personas;
GeeIterator *iter;
EmpathyContact *contact = NULL;
g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
personas = folks_individual_get_personas (individual);
iter = gee_iterable_iterator (GEE_ITERABLE (personas));
while (gee_iterator_next (iter) && (contact == NULL))
{
TpfPersona *persona = gee_iterator_get (iter);
if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
{
TpContact *tp_contact;
tp_contact = tpf_persona_get_contact (persona);
if (tp_contact != NULL)
{
contact = empathy_contact_dup_from_tp_contact (tp_contact);
empathy_contact_set_persona (contact, FOLKS_PERSONA (persona));
}
}
g_clear_object (&persona);
}
g_clear_object (&iter);
if (contact == NULL)
{
DEBUG ("Can't create an EmpathyContact for Individual %s",
folks_individual_get_id (individual));
}
return contact;
}
/**
* 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)
{
GeeSet *personas;
GeeIterator *iter;
gboolean retval = FALSE;
g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self), FALSE);
personas = folks_individual_get_personas (individual);
iter = gee_iterable_iterator (GEE_ITERABLE (personas));
while (!retval && gee_iterator_next (iter))
{
TpfPersona *persona = gee_iterator_get (iter);
TpConnection *conn;
if (TPF_IS_PERSONA (persona))
{
TpContact *tp_contact;
tp_contact = tpf_persona_get_contact (persona);
if (tp_contact != NULL)
{
conn = tp_contact_get_connection (tp_contact);
if (tp_proxy_has_interface_by_id (conn,
TP_IFACE_QUARK_CONNECTION_INTERFACE_CONTACT_BLOCKING))
retval = TRUE;
}
}
g_clear_object (&persona);
}
g_clear_object (&iter);
return retval;
}
static void
update_persona (EmpathyPersonaStore *self,
FolksPersona *persona)
{
EmpathyPersonaStorePriv *priv = GET_PRIV (self);
GtkTreePath *path;
gboolean do_set_active = FALSE;
gboolean do_set_refresh = FALSE;
const gchar *alias;
path = find_persona (self, persona);
alias = folks_aliasable_get_alias (FOLKS_ALIASABLE (persona));
if (path == NULL)
{
DEBUG ("Contact:'%s' in list:NO, should be:YES", alias);
add_persona (self, persona);
if (priv->show_active)
{
do_set_active = TRUE;
DEBUG ("Set active (contact added)");
}
}
else
{
FolksPersonaStore *store;
EmpathyContact *contact;
GtkTreeIter iter;
GdkPixbuf *pixbuf_avatar;
GdkPixbuf *pixbuf_status;
gboolean now_online = FALSE;
gboolean was_online = TRUE;
DEBUG ("Contact:'%s' in list:YES, should be:YES", alias);
gtk_tree_model_get_iter (GTK_TREE_MODEL (self), &iter, path);
gtk_tree_path_free (path);
/* Get online state now. */
now_online = folks_presence_is_online (FOLKS_PRESENCE (persona));
/* Get online state before. */
gtk_tree_model_get (GTK_TREE_MODEL (self), &iter,
EMPATHY_PERSONA_STORE_COL_IS_ONLINE, &was_online,
-1);
/* Is this really an update or an online/offline. */
if (priv->show_active)
{
if (was_online != now_online)
{
do_set_active = TRUE;
do_set_refresh = TRUE;
DEBUG ("Set active (contact updated %s)",
was_online ? "online -> offline" : "offline -> online");
}
else
{
/* Was TRUE for presence updates. */
/* do_set_active = FALSE; */
do_set_refresh = TRUE;
DEBUG ("Set active (contact updated)");
}
}
/* We still need to use EmpathyContact for the capabilities stuff */
contact = empathy_contact_dup_from_tp_contact (tpf_persona_get_contact (
TPF_PERSONA (persona)));
store = folks_persona_get_store (persona);
pixbuf_avatar = empathy_pixbuf_avatar_from_contact_scaled (contact,
32, 32);
pixbuf_status = get_persona_status_icon (self, persona);
gtk_list_store_set (GTK_LIST_STORE (self), &iter,
EMPATHY_PERSONA_STORE_COL_ICON_STATUS, pixbuf_status,
EMPATHY_PERSONA_STORE_COL_PIXBUF_AVATAR, pixbuf_avatar,
EMPATHY_PERSONA_STORE_COL_PIXBUF_AVATAR_VISIBLE, priv->show_avatars,
EMPATHY_PERSONA_STORE_COL_NAME, alias,
EMPATHY_PERSONA_STORE_COL_ACCOUNT_NAME,
folks_persona_store_get_display_name (store),
EMPATHY_PERSONA_STORE_COL_DISPLAY_ID,
folks_persona_get_display_id (persona),
EMPATHY_PERSONA_STORE_COL_PRESENCE_TYPE,
folks_presence_get_presence_type (FOLKS_PRESENCE (persona)),
EMPATHY_PERSONA_STORE_COL_STATUS,
folks_presence_get_presence_message (FOLKS_PRESENCE (persona)),
EMPATHY_PERSONA_STORE_COL_IS_ONLINE, now_online,
EMPATHY_PERSONA_STORE_COL_CAN_AUDIO_CALL,
empathy_contact_get_capabilities (contact) &
EMPATHY_CAPABILITIES_AUDIO,
EMPATHY_PERSONA_STORE_COL_CAN_VIDEO_CALL,
empathy_contact_get_capabilities (contact) &
EMPATHY_CAPABILITIES_VIDEO,
-1);
g_object_unref (contact);
if (pixbuf_avatar)
g_object_unref (pixbuf_avatar);
}
if (priv->show_active && do_set_active)
{
persona_set_active (self, persona, do_set_active, do_set_refresh);
if (do_set_active)
{
ShowActiveData *data;
data = persona_active_new (self, persona, FALSE);
data->timeout = g_timeout_add_seconds (ACTIVE_USER_SHOW_TIME,
(GSourceFunc) persona_active_cb,
data);
}
}
/* FIXME: when someone goes online then offline quickly, the
* first timeout sets the user to be inactive and the second
* timeout removes the user from the contact list, really we
* should remove the first timeout.
*/
}
/*
* Block contact dialog
*/
gboolean
empathy_block_individual_dialog_show (GtkWindow *parent,
FolksIndividual *individual,
GdkPixbuf *avatar,
gboolean *abusive)
{
GtkWidget *dialog;
GtkWidget *abusive_check = NULL;
GeeSet *personas;
GeeIterator *iter;
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_alias_details_get_alias (FOLKS_ALIAS_DETAILS (individual)));
if (avatar != NULL)
{
GtkWidget *image = gtk_image_new_from_pixbuf (avatar);
gtk_message_dialog_set_image (GTK_MESSAGE_DIALOG (dialog), image);
gtk_widget_show (image);
}
/* build a list of personas that support blocking */
personas = folks_individual_get_personas (individual);
iter = gee_iterable_iterator (GEE_ITERABLE (personas));
while (gee_iterator_next (iter))
{
TpfPersona *persona = gee_iterator_get (iter);
TpContact *contact;
GString *s;
char *str;
TpConnection *conn;
if (!TPF_IS_PERSONA (persona))
goto while_finish;
contact = tpf_persona_get_contact (persona);
if (contact == NULL)
goto while_finish;
conn = tp_contact_get_connection (contact);
if (tp_proxy_has_interface_by_id (conn,
TP_IFACE_QUARK_CONNECTION_INTERFACE_CONTACT_BLOCKING))
{
s = blocked_str;
npersonas_blocked++;
}
else
{
s = notblocked_str;
npersonas_notblocked++;
}
if (tp_connection_can_report_abusive (conn))
can_report_abuse = TRUE;
str = contact_pretty_name (contact);
g_string_append_printf (s, "\n " BULLET_POINT " %s", str);
g_free (str);
while_finish:
g_clear_object (&persona);
}
g_clear_object (&iter);
g_string_append_printf (text,
_("Are you sure you want to block '%s' from contacting you again?"),
folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (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_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;
}
static gboolean
query_tooltip_cb (EmpathyPersonaView *self,
gint x,
gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
gpointer user_data)
{
EmpathyPersonaViewPriv *priv = GET_PRIV (self);
FolksPersona *persona;
TpContact *tp_contact;
EmpathyContact *contact;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
static gint running = 0;
gboolean ret = FALSE;
/* Avoid an infinite loop. See GNOME bug #574377 */
if (running > 0)
return FALSE;
running++;
if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (self), &x, &y,
keyboard_mode, &model, &path, &iter))
{
goto OUT;
}
gtk_tree_view_set_tooltip_row (GTK_TREE_VIEW (self), tooltip, path);
gtk_tree_path_free (path);
gtk_tree_model_get (model, &iter,
EMPATHY_PERSONA_STORE_COL_PERSONA, &persona,
-1);
if (persona == NULL)
goto OUT;
tp_contact = tpf_persona_get_contact (TPF_PERSONA (persona));
if (tp_contact == NULL)
{
g_clear_object (&persona);
goto OUT;
}
contact = empathy_contact_dup_from_tp_contact (tp_contact);
if (priv->tooltip_widget == NULL)
{
priv->tooltip_widget = empathy_contact_widget_new (contact,
EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP |
EMPATHY_CONTACT_WIDGET_SHOW_LOCATION);
gtk_container_set_border_width (GTK_CONTAINER (priv->tooltip_widget), 8);
g_object_ref (priv->tooltip_widget);
g_signal_connect (priv->tooltip_widget, "destroy",
(GCallback) tooltip_destroy_cb, self);
gtk_widget_show (priv->tooltip_widget);
}
else
{
empathy_contact_widget_set_contact (priv->tooltip_widget, contact);
}
gtk_tooltip_set_custom (tooltip, priv->tooltip_widget);
ret = TRUE;
g_object_unref (contact);
g_object_unref (persona);
OUT:
running--;
return ret;
}