static void
link_individual (EmpathyIndividualLinker *self,
FolksIndividual *individual)
{
EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
GList *new_persona_list;
/* Add the individual to the link */
g_hash_table_insert (priv->changed_individuals, individual,
GUINT_TO_POINTER (TRUE));
/* Add personas which are in @individual to priv->new_individual, appending
* them to the list of personas.
* This is rather slow. */
new_persona_list = g_list_copy (folks_individual_get_personas (
priv->new_individual));
new_persona_list = g_list_concat (new_persona_list,
g_list_copy (folks_individual_get_personas (individual)));
folks_individual_set_personas (priv->new_individual, new_persona_list);
g_list_free (new_persona_list);
/* Update the toggle renderers, so that if this Individual is listed in
* another group in the EmpathyIndividualView, the toggle button for that
* group is updated. */
update_toggle_renderers (self);
g_object_notify (G_OBJECT (self), "has-changed");
}
static void
unlink_individual (EmpathyIndividualLinker *self,
FolksIndividual *individual)
{
EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
GList *new_persona_list, *old_persona_list, *removing_personas, *l;
/* Remove the individual from the link */
g_hash_table_remove (priv->changed_individuals, individual);
/* Remove personas which are in @individual from priv->new_individual.
* This is rather slow. */
old_persona_list = folks_individual_get_personas (priv->new_individual);
removing_personas = folks_individual_get_personas (individual);
new_persona_list = NULL;
for (l = old_persona_list; l != NULL; l = l->next)
{
GList *removing = g_list_find (removing_personas, l->data);
if (removing == NULL)
new_persona_list = g_list_prepend (new_persona_list, l->data);
}
new_persona_list = g_list_reverse (new_persona_list);
folks_individual_set_personas (priv->new_individual, new_persona_list);
g_list_free (new_persona_list);
/* Update the toggle renderers, so that if this Individual is listed in
* another group in the EmpathyIndividualView, the toggle button for that
* group is updated. */
update_toggle_renderers (self);
g_object_notify (G_OBJECT (self), "has-changed");
}
/* 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;
}
/* 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;
}
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;
}
/**
* empathy_persona_store_set_individual:
* @self: an #EmpathyPersonaStore
* @individual: the new individual to display in the store, or %NULL
*
* Set #EmpathyPersonaStore:individual to @individual, replacing the personas
* which were in the store with the personas belonging to @individual, or with
* nothing if @individual is %NULL.
*/
void
empathy_persona_store_set_individual (EmpathyPersonaStore *self,
FolksIndividual *individual)
{
EmpathyPersonaStorePriv *priv;
g_return_if_fail (EMPATHY_IS_PERSONA_STORE (self));
g_return_if_fail (individual == NULL || FOLKS_IS_INDIVIDUAL (individual));
priv = GET_PRIV (self);
/* Remove the old individual */
if (priv->individual != NULL)
{
GList *personas, *l;
g_signal_handlers_disconnect_by_func (priv->individual,
(GCallback) individual_personas_changed_cb, self);
/* Disconnect from and remove all personas belonging to this individual */
personas = folks_individual_get_personas (priv->individual);
for (l = personas; l != NULL; l = l->next)
remove_persona_and_disconnect (self, FOLKS_PERSONA (l->data));
g_object_unref (priv->individual);
}
priv->individual = individual;
/* Add the new individual */
if (individual != NULL)
{
GList *personas, *l;
g_object_ref (individual);
g_signal_connect (individual, "personas-changed",
(GCallback) individual_personas_changed_cb, self);
/* Add pre-existing Personas */
personas = folks_individual_get_personas (individual);
for (l = personas; l != NULL; l = l->next)
add_persona_and_connect (self, FOLKS_PERSONA (l->data));
}
g_object_notify (G_OBJECT (self), "individual");
}
/* @words = tpaw_live_search_strip_utf8_string (@text);
*
* User has to pass both so we don't have to compute @words ourself each time
* this function is called. */
gboolean
empathy_individual_match_string (FolksIndividual *individual,
const char *text,
GPtrArray *words)
{
const gchar *str;
GeeSet *personas;
GeeIterator *iter;
gboolean retval = FALSE;
/* check alias name */
str = folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (individual));
if (tpaw_live_search_match_words (str, words))
return TRUE;
personas = folks_individual_get_personas (individual);
/* check contact id, remove the @server.com part */
iter = gee_iterable_iterator (GEE_ITERABLE (personas));
while (retval == FALSE && gee_iterator_next (iter))
{
FolksPersona *persona = gee_iterator_get (iter);
const gchar *p;
if (empathy_folks_persona_is_interesting (persona))
{
str = folks_persona_get_display_id (persona);
/* Accept the persona if @text is a full prefix of his ID; that allows
* user to find, say, a jabber contact by typing his JID. */
if (g_str_has_prefix (str, text))
{
retval = TRUE;
}
else
{
gchar *dup_str = NULL;
gboolean visible;
p = strstr (str, "@");
if (p != NULL)
str = dup_str = g_strndup (str, p - str);
visible = tpaw_live_search_match_words (str, words);
g_free (dup_str);
if (visible)
retval = TRUE;
}
}
g_clear_object (&persona);
}
g_clear_object (&iter);
/* FIXME: Add more rules here, we could check phone numbers in
* contact's vCard for example. */
return retval;
}
/* 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 void
link_individual (EmpathyIndividualLinker *self,
FolksIndividual *individual)
{
EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
GeeSet *old_personas, *new_personas;
GeeHashSet *final_personas;
gboolean personas_changed;
/* Add the individual to the link */
g_hash_table_insert (priv->changed_individuals, individual,
GUINT_TO_POINTER (TRUE));
/* Add personas which are in @individual to priv->new_individual, adding them
* to the set of personas. */
old_personas = folks_individual_get_personas (individual);
new_personas = folks_individual_get_personas (priv->new_individual);
final_personas = gee_hash_set_new (FOLKS_TYPE_PERSONA, g_object_ref,
g_object_unref, g_direct_hash, g_direct_equal);
gee_collection_add_all (GEE_COLLECTION (final_personas),
GEE_COLLECTION (old_personas));
personas_changed = gee_collection_add_all (GEE_COLLECTION (final_personas),
GEE_COLLECTION (new_personas));
/* avoid updating all values in the Individual if the set of personas doesn't
* actually change */
if (personas_changed)
{
folks_individual_set_personas (priv->new_individual,
GEE_SET (final_personas));
}
g_clear_object (&final_personas);
/* Update the toggle renderers, so that if this Individual is listed in
* another group in the EmpathyIndividualView, the toggle button for that
* group is updated. */
update_toggle_renderers (self);
g_object_notify (G_OBJECT (self), "has-changed");
}
static void
unlink_individual (EmpathyIndividualLinker *self,
FolksIndividual *individual)
{
EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
GeeSet *removed_personas, *old_personas;
GeeHashSet *final_personas;
gboolean personas_changed;
/* Remove the individual from the link */
g_hash_table_remove (priv->changed_individuals, individual);
/* Remove personas which are in @individual from priv->new_individual. */
old_personas = folks_individual_get_personas (priv->new_individual);
removed_personas = folks_individual_get_personas (individual);
final_personas = gee_hash_set_new (FOLKS_TYPE_PERSONA, g_object_ref,
g_object_unref, g_direct_hash, g_direct_equal);
gee_collection_add_all (GEE_COLLECTION (final_personas),
GEE_COLLECTION (old_personas));
personas_changed = gee_collection_remove_all (GEE_COLLECTION (final_personas),
GEE_COLLECTION (removed_personas));
if (personas_changed)
{
folks_individual_set_personas (priv->new_individual,
GEE_SET (final_personas));
}
g_clear_object (&final_personas);
/* Update the toggle renderers, so that if this Individual is listed in
* another group in the EmpathyIndividualView, the toggle button for that
* group is updated. */
update_toggle_renderers (self);
g_object_notify (G_OBJECT (self), "has-changed");
}
/**
* empathy_individual_linker_get_linked_personas:
* @self: an #EmpathyIndividualLinker
*
* Return a list of the #FolksPersona<!-- -->s which comprise the linked
* individual currently displayed in the widget.
*
* The return value is guaranteed to contain at least one element.
*
* Return value: (transfer none) (element-type Folks.Persona): a set of
* #FolksPersona<!-- -->s to link together
*/
GeeSet *
empathy_individual_linker_get_linked_personas (EmpathyIndividualLinker *self)
{
EmpathyIndividualLinkerPriv *priv;
GeeSet *personas;
g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_LINKER (self), NULL);
priv = GET_PRIV (self);
if (priv->new_individual == NULL)
return NULL;
personas = folks_individual_get_personas (priv->new_individual);
g_assert (personas != NULL);
return personas;
}
static gboolean
check_writeable_property (TpConnection *connection,
FolksIndividual *individual,
gchar *property)
{
gchar **properties;
gint prop_len;
gboolean retval = FALSE;
GeeSet *personas;
GeeIterator *iter;
FolksPersonaStore *persona_store;
persona_store = FOLKS_PERSONA_STORE (
empathy_dup_persona_store_for_connection (connection));
properties =
folks_persona_store_get_always_writeable_properties (persona_store,
&prop_len);
retval = properties_contains (properties, prop_len, property);
if (retval == TRUE)
goto out;
/* Lets see if the Individual contains a Persona with the given property */
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);
properties =
folks_persona_get_writeable_properties (persona, &prop_len);
retval = properties_contains (properties, prop_len, property);
g_clear_object (&persona);
if (retval == TRUE)
break;
}
g_clear_object (&iter);
out:
g_clear_object (&persona_store);
return retval;
}
/**
* empathy_individual_linker_set_start_individual:
* @self: an #EmpathyIndividualLinker
* @individual: (allow-none): the start individual, or %NULL
*
* Set the value of #EmpathyIndividualLinker:start-individual to @individual.
*/
void
empathy_individual_linker_set_start_individual (EmpathyIndividualLinker *self,
FolksIndividual *individual)
{
EmpathyIndividualLinkerPriv *priv;
g_return_if_fail (EMPATHY_IS_INDIVIDUAL_LINKER (self));
g_return_if_fail (individual == NULL || FOLKS_IS_INDIVIDUAL (individual));
priv = GET_PRIV (self);
tp_clear_object (&priv->start_individual);
tp_clear_object (&priv->new_individual);
g_hash_table_remove_all (priv->changed_individuals);
if (individual != NULL)
{
priv->start_individual = g_object_ref (individual);
priv->new_individual = folks_individual_new (
folks_individual_get_personas (individual));
empathy_individual_view_set_store (priv->individual_view,
priv->individual_store);
}
else
{
priv->start_individual = NULL;
priv->new_individual = NULL;
/* We only display Individuals in the individual view if we have a
* new_individual to link them into */
empathy_individual_view_set_store (priv->individual_view, NULL);
}
empathy_individual_widget_set_individual (
EMPATHY_INDIVIDUAL_WIDGET (priv->preview_widget), priv->new_individual);
empathy_persona_store_set_individual (priv->persona_store,
priv->new_individual);
g_object_freeze_notify (G_OBJECT (self));
g_object_notify (G_OBJECT (self), "start-individual");
g_object_notify (G_OBJECT (self), "has-changed");
g_object_thaw_notify (G_OBJECT (self));
}
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;
}
/*
* 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;
}
