empathy_contact_manager_dup_singleton ();
GtkWidget *dialog;
GtkWidget *abusive_check = NULL;
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
GString *text = g_string_new ("");
GString *blocked_str = g_string_new ("");
GString *notblocked_str = g_string_new ("");
/* build a list of personas that support blocking */
personas = folks_individual_get_personas (individual);
-
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
- TpfPersona *persona = l->data;
+ TpfPersona *persona = gee_iterator_get (iter);
TpContact *contact;
EmpathyContactListFlags flags;
GString *s;
char *str;
if (!TPF_IS_PERSONA (persona))
- continue;
+ goto while_finish;
contact = tpf_persona_get_contact (persona);
flags = empathy_contact_manager_get_flags_for_connection (
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?"),
set_label_visibility (EmpathyIndividualInformationDialog *dialog)
{
EmpathyIndividualInformationDialogPriv *priv = GET_PRIV (dialog);
- GList *personas, *l;
guint num_personas = 0;
/* Count how many Telepathy personas we have, to see whether we can
* unlink */
if (priv->individual != NULL)
{
+ GeeSet *personas;
+ GeeIterator *iter;
+
personas = folks_individual_get_personas (priv->individual);
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
- if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
+ FolksPersona *persona = gee_iterator_get (iter);
+ if (empathy_folks_persona_is_interesting (persona))
num_personas++;
+
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
}
/* Only make the label visible if we have enough personas */
FolksIndividual *individual)
{
EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
- GList *new_persona_list;
+ 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, 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);
+ /* 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
FolksIndividual *individual)
{
EmpathyIndividualLinkerPriv *priv = GET_PRIV (self);
- GList *new_persona_list, *old_persona_list, *removing_personas, *l;
+ 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.
- * 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;
+ /* 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);
- for (l = old_persona_list; l != NULL; l = l->next)
- {
- GList *removing = g_list_find (removing_personas, l->data);
+ 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 (removing == NULL)
- new_persona_list = g_list_prepend (new_persona_list, l->data);
+ if (personas_changed)
+ {
+ folks_individual_set_personas (priv->new_individual,
+ GEE_SET (final_personas));
}
- 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);
+ 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
*
* The return value is guaranteed to contain at least one element.
*
- * Return value: (transfer none) (element-type Folks.Persona): a list of
+ * Return value: (transfer none) (element-type Folks.Persona): a set of
* #FolksPersona<!-- -->s to link together
*/
-GList *
+GeeSet *
empathy_individual_linker_get_linked_personas (EmpathyIndividualLinker *self)
{
EmpathyIndividualLinkerPriv *priv;
- GList *personas;
+ GeeSet *personas;
g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_LINKER (self), NULL);
EmpathyIndividualLinker *self,
FolksIndividual *individual);
-GList * empathy_individual_linker_get_linked_personas (
+GeeSet * empathy_individual_linker_get_linked_personas (
EmpathyIndividualLinker *self);
gboolean empathy_individual_linker_get_has_changed (
EmpathyIndividualFeatureFlags features)
{
GtkWidget *item;
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
guint persona_count = 0;
+ gboolean c;
g_return_if_fail (GTK_IS_MENU (menu));
g_return_if_fail (FOLKS_IS_INDIVIDUAL (individual));
g_return_if_fail (empathy_folks_individual_contains_contact (individual));
personas = folks_individual_get_personas (individual);
+ /* we'll re-use this iterator throughout */
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
/* Make sure we've got enough valid entries for these menu items to add
* functionality */
- for (l = personas; l != NULL; l = l->next)
+ while (gee_iterator_next (iter))
{
- if (!empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
- continue;
+ FolksPersona *persona = gee_iterator_get (iter);
+ if (empathy_folks_persona_is_interesting (persona))
+ persona_count++;
- persona_count++;
+ g_clear_object (&persona);
}
/* return early if these entries would add nothing beyond the "quick" items */
gtk_widget_show (item);
personas = folks_individual_get_personas (individual);
- for (l = personas; l != NULL; l = l->next)
+ for (c = gee_iterator_first (iter); c; c = gee_iterator_next (iter))
{
GtkWidget *image;
GtkWidget *contact_item;
GtkWidget *contact_submenu;
TpContact *tp_contact;
EmpathyContact *contact;
- TpfPersona *persona = l->data;
+ TpfPersona *persona = gee_iterator_get (iter);
gchar *label;
FolksPersonaStore *store;
const gchar *account;
GtkWidget *action;
- if (!empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
- continue;
+ if (!empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
+ goto while_finish;
tp_contact = tpf_persona_get_contact (persona);
contact = empathy_contact_dup_from_tp_contact (tp_contact);
g_free (label);
g_object_unref (contact);
+
+while_finish:
+ g_clear_object (&persona);
}
+
+ g_clear_object (&iter);
}
static void
EmpathyTpChat *chat;
EmpathyChatroomManager *mgr;
EmpathyContact *contact = NULL;
- GList *personas, *l;
chat = empathy_chatroom_get_tp_chat (data->chatroom);
if (chat == NULL)
contact = g_object_ref (data->contact);
else
{
+ GeeSet *personas;
+ GeeIterator *iter;
+
/* find the first of this Individual's contacts who can join this room */
personas = folks_individual_get_personas (data->individual);
- for (l = personas; l != NULL && contact == NULL; l = g_list_next (l))
+
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter) && (contact == NULL))
{
- TpfPersona *persona = l->data;
+ TpfPersona *persona = gee_iterator_get (iter);
TpContact *tp_contact;
GList *rooms;
- if (!empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
- continue;
-
- tp_contact = tpf_persona_get_contact (persona);
- contact = empathy_contact_dup_from_tp_contact (tp_contact);
+ if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
+ {
+ tp_contact = tpf_persona_get_contact (persona);
+ contact = empathy_contact_dup_from_tp_contact (tp_contact);
- rooms = empathy_chatroom_manager_get_chatrooms (mgr,
- empathy_contact_get_account (contact));
+ rooms = empathy_chatroom_manager_get_chatrooms (mgr,
+ empathy_contact_get_account (contact));
- if (g_list_find (rooms, data->chatroom) == NULL)
- tp_clear_object (&contact);
+ if (g_list_find (rooms, data->chatroom) == NULL)
+ g_clear_object (&contact);
- /* if contact != NULL here, we've found our match */
+ /* if contact != NULL here, we've found our match */
- g_list_free (rooms);
+ g_list_free (rooms);
+ }
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
}
g_object_unref (mgr);
GtkWidget *image;
GtkWidget *room_item;
EmpathyChatroomManager *mgr;
- GList *personas;
GList *rooms = NULL;
GList *names = NULL;
GList *l;
}
else
{
- /* collect the rooms from amongst all accounts for this Individual */
+ GeeSet *personas;
+ GeeIterator *iter;
+
+ /* find the first of this Individual's contacts who can join this room */
personas = folks_individual_get_personas (individual);
- for (l = personas; l != NULL; l = g_list_next (l))
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
- TpfPersona *persona = l->data;
+ TpfPersona *persona = gee_iterator_get (iter);
GList *rooms_cur;
TpContact *tp_contact;
EmpathyContact *contact_cur;
- if (!empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
- continue;
-
- tp_contact = tpf_persona_get_contact (persona);
- contact_cur = empathy_contact_dup_from_tp_contact (tp_contact);
+ if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
+ {
+ tp_contact = tpf_persona_get_contact (persona);
+ contact_cur = empathy_contact_dup_from_tp_contact (tp_contact);
- rooms_cur = empathy_chatroom_manager_get_chatrooms (mgr,
- empathy_contact_get_account (contact_cur));
- rooms = g_list_concat (rooms, rooms_cur);
+ rooms_cur = empathy_chatroom_manager_get_chatrooms (mgr,
+ empathy_contact_get_account (contact_cur));
+ rooms = g_list_concat (rooms, rooms_cur);
- g_object_unref (contact_cur);
+ g_object_unref (contact_cur);
+ }
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
}
/* alphabetize the rooms */
gboolean *can_audio_call,
gboolean *can_video_call)
{
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
gboolean can_audio = FALSE, can_video = FALSE;
personas = folks_individual_get_personas (individual);
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
+ FolksPersona *persona = gee_iterator_get (iter);
TpContact *tp_contact;
EmpathyContact *contact;
- if (!empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
- continue;
+ if (!empathy_folks_persona_is_interesting (persona))
+ goto while_finish;
- tp_contact = tpf_persona_get_contact (TPF_PERSONA (l->data));
+ tp_contact = tpf_persona_get_contact (TPF_PERSONA (persona));
contact = empathy_contact_dup_from_tp_contact (tp_contact);
- empathy_contact_set_persona (contact, FOLKS_PERSONA (l->data));
+ empathy_contact_set_persona (contact, persona);
can_audio = can_audio || empathy_contact_get_capabilities (contact) &
EMPATHY_CAPABILITIES_AUDIO;
EMPATHY_CAPABILITIES_VIDEO;
g_object_unref (contact);
+while_finish:
+ g_clear_object (&persona);
if (can_audio && can_video)
break;
}
+ g_clear_object (&iter);
*can_audio_call = can_audio;
*can_video_call = can_video;
static const gchar * const *
individual_get_client_types (FolksIndividual *individual)
{
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
const gchar * const *types = NULL;
FolksPresenceType presence_type = FOLKS_PRESENCE_TYPE_UNSET;
personas = folks_individual_get_personas (individual);
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
FolksPresenceDetails *presence;
+ FolksPersona *persona = gee_iterator_get (iter);
/* We only want personas which have presence and a TpContact */
if (!empathy_folks_persona_is_interesting (persona))
- continue;
+ goto while_finish;
- presence = FOLKS_PRESENCE_DETAILS (l->data);
+ presence = FOLKS_PRESENCE_DETAILS (persona);
if (folks_presence_details_typecmp (
folks_presence_details_get_presence_type (presence),
presence_type = folks_presence_details_get_presence_type (presence);
- tp_contact = tpf_persona_get_contact (TPF_PERSONA (l->data));
+ tp_contact = tpf_persona_get_contact (TPF_PERSONA (persona));
types = tp_contact_get_client_types (tp_contact);
}
+
+while_finish:
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
return types;
}
static void
individual_personas_changed_cb (FolksIndividual *individual,
- GList *added,
- GList *removed,
+ GeeSet *added,
+ GeeSet *removed,
EmpathyIndividualStore *self)
{
- GList *l;
+ GeeIterator *iter;
DEBUG ("Individual '%s' personas-changed.",
folks_individual_get_id (individual));
+ iter = gee_iterable_iterator (GEE_ITERABLE (removed));
/* FIXME: libfolks hasn't grown capabilities support yet, so we have to go
* through the EmpathyContacts for them. */
- for (l = removed; l != NULL; l = l->next)
+ while (gee_iterator_next (iter))
{
+ TpfPersona *persona = gee_iterator_get (iter);
TpContact *tp_contact;
EmpathyContact *contact;
- if (!TPF_IS_PERSONA (l->data))
- continue;
+ if (TPF_IS_PERSONA (persona))
+ {
+ tp_contact = tpf_persona_get_contact (persona);
+ contact = empathy_contact_dup_from_tp_contact (tp_contact);
+ empathy_contact_set_persona (contact, FOLKS_PERSONA (persona));
- tp_contact = tpf_persona_get_contact (TPF_PERSONA (l->data));
- contact = empathy_contact_dup_from_tp_contact (tp_contact);
- empathy_contact_set_persona (contact, FOLKS_PERSONA (l->data));
+ g_object_set_data (G_OBJECT (contact), "individual", NULL);
+ g_signal_handlers_disconnect_by_func (contact,
+ (GCallback) individual_store_contact_updated_cb, self);
- g_object_set_data (G_OBJECT (contact), "individual", NULL);
- g_signal_handlers_disconnect_by_func (contact,
- (GCallback) individual_store_contact_updated_cb, self);
+ g_object_unref (contact);
+ }
- g_object_unref (contact);
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
- for (l = added; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (added));
+ while (gee_iterator_next (iter))
{
+ TpfPersona *persona = gee_iterator_get (iter);
TpContact *tp_contact;
EmpathyContact *contact;
- if (!TPF_IS_PERSONA (l->data))
- continue;
+ if (TPF_IS_PERSONA (persona))
+ {
+ tp_contact = tpf_persona_get_contact (persona);
+ contact = empathy_contact_dup_from_tp_contact (tp_contact);
+ empathy_contact_set_persona (contact, FOLKS_PERSONA (persona));
- tp_contact = tpf_persona_get_contact (TPF_PERSONA (l->data));
- contact = empathy_contact_dup_from_tp_contact (tp_contact);
- empathy_contact_set_persona (contact, FOLKS_PERSONA (l->data));
+ g_object_set_data (G_OBJECT (contact), "individual", individual);
+ g_signal_connect (contact, "notify::capabilities",
+ (GCallback) individual_store_contact_updated_cb, self);
+ g_signal_connect (contact, "notify::client-types",
+ (GCallback) individual_store_contact_updated_cb, self);
- g_object_set_data (G_OBJECT (contact), "individual", individual);
- g_signal_connect (contact, "notify::capabilities",
- (GCallback) individual_store_contact_updated_cb, self);
- g_signal_connect (contact, "notify::client-types",
- (GCallback) individual_store_contact_updated_cb, self);
+ g_object_unref (contact);
+ }
- g_object_unref (contact);
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
}
void
individual_store_add_individual_and_connect (EmpathyIndividualStore *self,
FolksIndividual *individual)
{
+ GeeSet *empty_set = gee_set_empty (G_TYPE_NONE, NULL, NULL);
+
individual_store_add_individual (self, individual);
g_signal_connect (individual, "notify::avatar",
g_signal_connect (individual, "personas-changed",
(GCallback) individual_personas_changed_cb, self);
+ /* provide an empty set so the callback can assume non-NULL sets */
individual_personas_changed_cb (individual,
- folks_individual_get_personas (individual), NULL, self);
+ folks_individual_get_personas (individual), empty_set, self);
+ g_clear_object (&empty_set);
}
static void
individual_store_disconnect_individual (EmpathyIndividualStore *self,
FolksIndividual *individual)
{
- individual_personas_changed_cb (individual, NULL,
+ GeeSet *empty_set = gee_set_empty (G_TYPE_NONE, NULL, NULL);
+
+ /* provide an empty set so the callback can assume non-NULL sets */
+ individual_personas_changed_cb (individual, empty_set,
folks_individual_get_personas (individual), self);
+ g_clear_object (&empty_set);
g_signal_handlers_disconnect_by_func (individual,
(GCallback) individual_store_individual_updated_cb, self);
EmpathyIndividualStorePriv *priv;
const gchar *protocol_name = NULL;
gchar *icon_name = NULL;
- GList *personas, *l;
- guint contact_count;
+ GeeSet *personas;
+ GeeIterator *iter;
+ guint contact_count = 0;
EmpathyContact *contact = NULL;
gboolean show_protocols_here;
priv = GET_PRIV (self);
personas = folks_individual_get_personas (individual);
- for (l = personas, contact_count = 0; l; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
- if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
+ FolksPersona *persona = gee_iterator_get (iter);
+ if (empathy_folks_persona_is_interesting (persona))
contact_count++;
+ g_clear_object (&persona);
+
if (contact_count > 1)
break;
}
+ g_clear_object (&iter);
show_protocols_here = (priv->show_protocols && (contact_count == 1));
if (show_protocols_here)
FolksPersona *persona = NULL;
const gchar *persona_uid;
GList *individuals, *l;
+ GeeIterator *iter = NULL;
gboolean retval = FALSE;
persona_uid = (const gchar *) gtk_selection_data_get_data (selection);
for (l = individuals; l != NULL; l = l->next)
{
- GList *personas, *p;
+ GeeSet *personas;
personas = folks_individual_get_personas (FOLKS_INDIVIDUAL (l->data));
-
- for (p = personas; p != NULL; p = p->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
- if (!tp_strdiff (folks_persona_get_uid (FOLKS_PERSONA (p->data)),
- persona_uid))
+ FolksPersona *persona_cur = gee_iterator_get (iter);
+
+ if (!tp_strdiff (folks_persona_get_uid (persona), persona_uid))
{
- persona = g_object_ref (p->data);
+ /* takes ownership of the ref */
+ persona = persona_cur;
individual = g_object_ref (l->data);
goto got_persona;
}
+ g_clear_object (&persona_cur);
}
+ g_clear_object (&iter);
}
got_persona:
+ g_clear_object (&iter);
g_list_free (individuals);
if (persona == NULL || individual == NULL)
{
EmpathyIndividualViewPriv *priv = GET_PRIV (self);
EmpathyLiveSearch *live = EMPATHY_LIVE_SEARCH (priv->search_widget);
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
gboolean is_favorite, contains_interesting_persona = FALSE;
/* We're only giving the visibility wrt filtering here, not things like
/* Hide all individuals which consist entirely of uninteresting personas */
personas = folks_individual_get_personas (individual);
- for (l = personas; l; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (!contains_interesting_persona && gee_iterator_next (iter))
{
- if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
- {
- contains_interesting_persona = TRUE;
- break;
- }
+ FolksPersona *persona = gee_iterator_get (iter);
+
+ if (empathy_folks_persona_is_interesting (persona))
+ contains_interesting_persona = TRUE;
+
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
if (contains_interesting_persona == FALSE)
return FALSE;
EmpathyIndividualManager *manager;
gchar *text;
GtkWindow *parent;
- GList *l, *personas;
+ GeeSet *personas;
+ GeeIterator *iter;
guint persona_count = 0;
gboolean can_block;
GError *error = NULL;
* so we still display the remove dialog. */
personas = folks_individual_get_personas (individual);
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
/* If we have more than one TpfPersona, display a different message
* ensuring the user knows that *all* of the meta-contacts' personas will
* be removed. */
- for (l = personas; l != NULL; l = l->next)
+ while (persona_count < 2 && gee_iterator_next (iter))
{
- if (!empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
- continue;
+ FolksPersona *persona = gee_iterator_get (iter);
+
+ if (empathy_folks_persona_is_interesting (persona))
+ persona_count++;
- persona_count++;
- if (persona_count >= 2)
- break;
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
if (persona_count < 2)
{
GtkWidget *item;
GtkWidget *image;
gboolean can_remove = FALSE;
- GList *l;
+ GeeSet *personas;
+ GeeIterator *iter;
g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_VIEW (view), NULL);
* remove. This will act as a best-effort option. If any Personas cannot be
* removed from the server, then this option will just be inactive upon
* subsequent menu openings */
- for (l = folks_individual_get_personas (individual); l != NULL; l = l->next)
+ personas = folks_individual_get_personas (individual);
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (!can_remove && gee_iterator_next (iter))
{
- FolksPersona *persona = FOLKS_PERSONA (l->data);
+ FolksPersona *persona = gee_iterator_get (iter);
FolksPersonaStore *store = folks_persona_get_store (persona);
FolksMaybeBool maybe_can_remove =
folks_persona_store_get_can_remove_personas (store);
if (maybe_can_remove == FOLKS_MAYBE_BOOL_TRUE)
- {
- can_remove = TRUE;
- break;
- }
+ can_remove = TRUE;
+
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
menu = empathy_individual_menu_new (individual, priv->individual_features);
* details for every TpContact in the Individual and merge them
* all, but that requires vCard support in libfolks for it to
* not be hideously complex. (bgo#627399) */
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
FolksPresenceType presence_type = FOLKS_PRESENCE_TYPE_UNSET;
personas = folks_individual_get_personas (priv->individual);
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
- FolksPresenceDetails *presence;
- FolksPresenceType presence_type_cur;
+ FolksPersona *persona = gee_iterator_get (iter);
/* We only want personas which have presence and a TpContact */
- if (!empathy_folks_persona_is_interesting (FOLKS_PERSONA (presence)))
- continue;
+ if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
+ {
+ FolksPresenceDetails *presence;
+ FolksPresenceType presence_type_cur;
- presence = FOLKS_PRESENCE_DETAILS (l->data);
- presence_type_cur = folks_presence_details_get_presence_type (
- presence);
+ presence = FOLKS_PRESENCE_DETAILS (persona);
+ presence_type_cur = folks_presence_details_get_presence_type (
+ presence);
- if (folks_presence_details_typecmp (
- presence_type_cur, presence_type) > 0)
- {
- presence_type = presence_type_cur;
- tp_contact = tpf_persona_get_contact (TPF_PERSONA (l->data));
+ if (folks_presence_details_typecmp (
+ presence_type_cur, presence_type) > 0)
+ {
+ presence_type = presence_type_cur;
+ tp_contact = tpf_persona_get_contact (TPF_PERSONA (persona));
+ }
}
+
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
}
if (tp_contact != NULL)
int i;
const gchar *skey;
gboolean display_map = FALSE;
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
if (!(priv->flags & EMPATHY_INDIVIDUAL_WIDGET_SHOW_LOCATION) ||
priv->individual == NULL)
/* FIXME: For the moment, we just display the first location data we can
* find amongst the Individual's Personas. Once libfolks grows a location
* interface, we can use that. (bgo#627400) */
+
personas = folks_individual_get_personas (priv->individual);
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (location == NULL && gee_iterator_next (iter))
{
- FolksPersona *persona = FOLKS_PERSONA (l->data);
+ FolksPersona *persona = gee_iterator_get (iter);
if (empathy_folks_persona_is_interesting (persona))
{
/* Try and get a location */
location = empathy_contact_get_location (contact);
- if (location != NULL && g_hash_table_size (location) > 0)
- break;
-
- location = NULL;
- tp_clear_object (&contact);
+ /* if location isn't fully valid, treat the contact as insufficient */
+ if (location != NULL && g_hash_table_size (location) <= 0)
+ {
+ location = NULL;
+ g_clear_object (&contact);
+ }
}
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
if (contact == NULL || location == NULL)
{
/* FIXME: For now, we have to do this manually. Once libfolks grows a
* location interface, we can use that. (bgo#627400) */
+
personas = folks_individual_get_personas (priv->individual);
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
- FolksPersona *persona = FOLKS_PERSONA (l->data);
+ FolksPersona *persona = gee_iterator_get (iter);
if (empathy_folks_persona_is_interesting (persona))
{
/* Try and get a location */
location = empathy_contact_get_location (contact);
if (location == NULL || g_hash_table_size (location) == 0)
- {
- g_object_unref (contact);
- continue;
- }
+ goto while_finish;
/* Get this persona's latitude and longitude */
value = g_hash_table_lookup (location, EMPATHY_LOCATION_LAT);
if (value == NULL)
- {
- g_object_unref (contact);
- continue;
- }
+ goto while_finish;
lat = g_value_get_double (value);
value = g_hash_table_lookup (location, EMPATHY_LOCATION_LON);
if (value == NULL)
- {
- g_object_unref (contact);
- continue;
- }
+ goto while_finish;
lon = g_value_get_double (value);
lat, lon);
champlain_marker_layer_add_marker (layer,
CHAMPLAIN_MARKER (marker));
-
- g_object_unref (contact);
}
+
+while_finish:
+ g_clear_object (&persona);
+ g_clear_object (&contact);
}
+ g_clear_object (&iter);
/* Zoom to show all of the markers */
champlain_view_ensure_layers_visible (priv->map_view, FALSE);
static EmpathyAvatar *
individual_dup_avatar (FolksIndividual *individual)
{
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
EmpathyAvatar *avatar = NULL;
/* FIXME: We just choose the first Persona which has an avatar, and save that.
* The avatar handling in EmpathyContact needs to be moved into libfolks as
* much as possible, and this code rewritten to use FolksHasAvatar.
* (bgo#627401) */
+
personas = folks_individual_get_personas (individual);
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (avatar == NULL && gee_iterator_next (iter))
{
- avatar = persona_dup_avatar (FOLKS_PERSONA (l->data));
- if (avatar != NULL)
- break;
+ FolksPersona *persona = gee_iterator_get (iter);
+ avatar = persona_dup_avatar (persona);
+
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
return avatar;
}
static TpAccount *
individual_is_user (FolksIndividual *individual)
{
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
+ TpAccount *retval = NULL;
/* FIXME: This should move into libfolks when libfolks grows a way of
* determining "self". (bgo#627402) */
personas = folks_individual_get_personas (individual);
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
- FolksPersona *persona = FOLKS_PERSONA (l->data);
+ FolksPersona *persona = gee_iterator_get (iter);
if (TPF_IS_PERSONA (persona))
{
/* Determine if the contact is the user */
if (empathy_contact_is_user (contact))
- {
- g_object_unref (contact);
- return g_object_ref (empathy_contact_get_account (contact));
- }
+ retval = g_object_ref (empathy_contact_get_account (contact));
g_object_unref (contact);
}
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
- return NULL;
+ return retval;
}
static void
{
gchar *message;
GtkWidget *label;
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
guint num_personas = 0;
/* Meta-contacts message displaying how many Telepathy personas we have */
personas = folks_individual_get_personas (priv->individual);
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
- if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
+ FolksPersona *persona = gee_iterator_get (iter);
+ if (empathy_folks_persona_is_interesting (persona))
num_personas++;
+
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
/* Translators: the plurality applies to both instances of the word
* "contact" */
EmpathyIndividualWidget *self)
{
EmpathyIndividualWidgetPriv *priv = GET_PRIV (self);
- GList *personas, *l, *children;
+ GList *l, *children;
+ GeeSet *personas;
+ GeeIterator *iter;
gboolean show_personas, was_showing_personas, will_show_personas, is_last;
guint old_num_personas, new_num_personas = 0;
personas = folks_individual_get_personas (individual);
+ /* we'll re-use this iterator throughout */
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
/* Note that old_num_personas is the number of persona tables we were
* displaying, not the number of Personas which were in the Individual
* before. */
old_num_personas = g_hash_table_size (priv->persona_tables);
- for (l = personas; l != NULL; l = l->next)
+ while (gee_iterator_next (iter))
{
- if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
+ FolksPersona *persona = gee_iterator_get (iter);
+ if (empathy_folks_persona_is_interesting (persona))
new_num_personas++;
+
+ g_clear_object (&persona);
}
/*
}
else if (!was_showing_personas && will_show_personas)
{
+ gboolean c;
+
/* Remove the old Individual table */
individual_table_destroy (self);
/* Set up all the Persona tables instead */
- for (l = personas; l != NULL; l = l->next)
- add_persona (self, FOLKS_PERSONA (l->data));
+ for (c = gee_iterator_first (iter); c; c = gee_iterator_next (iter))
+ {
+ FolksPersona *persona = gee_iterator_get (iter);
+ add_persona (self, persona);
+ g_clear_object (&persona);
+ }
}
else if (was_showing_personas && !will_show_personas)
{
+ gboolean c;
+
/* Remove all Personas */
- for (l = personas; l != NULL; l = l->next)
- remove_persona (self, FOLKS_PERSONA (l->data));
+ for (c = gee_iterator_first (iter); c; c = gee_iterator_next (iter))
+ {
+ FolksPersona *persona = gee_iterator_get (iter);
+ remove_persona (self, persona);
+ g_clear_object (&persona);
+ }
+
for (l = removed; l != NULL; l = l->next)
remove_persona (self, FOLKS_PERSONA (l->data));
/* Set up the Individual table instead */
individual_table_set_up (self);
}
+ g_clear_object (&iter);
/* Hide the last separator and show the others */
children = gtk_container_get_children (GTK_CONTAINER (priv->vbox_individual));
EmpathyIndividualWidgetPriv *priv = GET_PRIV (self);
if (priv->individual != NULL)
{
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
g_signal_handlers_disconnect_by_func (priv->individual,
notify_alias_cb, self);
}
personas = folks_individual_get_personas (priv->individual);
- for (l = personas; l != NULL; l = l->next)
- remove_persona (self, FOLKS_PERSONA (l->data));
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
+ {
+ FolksPersona *persona = gee_iterator_get (iter);
+ remove_persona (self, persona);
+ g_clear_object (&persona);
+ }
+ g_clear_object (&iter);
individual_table_destroy (self);
if (priv->contact != NULL)
else
{
/* We need to update the details for every Persona in the Individual */
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
personas = folks_individual_get_personas (priv->individual);
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
- if (!empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
- continue;
+ FolksPersona *persona = gee_iterator_get (iter);
+
+ if (empathy_folks_persona_is_interesting (persona))
+ update_persona (self, persona);
- update_persona (self, FOLKS_PERSONA (l->data));
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
gtk_widget_show (priv->vbox_individual);
}
if (response == GTK_RESPONSE_OK)
{
EmpathyIndividualManager *manager;
- GList *personas;
+ GeeSet *personas;
manager = empathy_individual_manager_dup_singleton ();
GtkWindow *parent)
{
EmpathyLinkingDialogPriv *priv;
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
guint num_personas = 0;
/* Create the dialogue if it doesn't exist */
/* Count how many Telepathy personas we have, to see whether we can
* unlink */
personas = folks_individual_get_personas (individual);
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
- if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
+ FolksPersona *persona = gee_iterator_get (iter);
+ if (empathy_folks_persona_is_interesting (persona))
num_personas++;
+
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
/* Only make the "Unlink" button sensitive if we have enough personas */
gtk_dialog_set_response_sensitive (GTK_DIALOG (linking_dialog),
/* Remove the old individual */
if (priv->individual != NULL)
{
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
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));
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
+ {
+ FolksPersona *persona = gee_iterator_get (iter);
+ remove_persona_and_disconnect (self, persona);
+ g_clear_object (&persona);
+ }
+ g_clear_object (&iter);
g_object_unref (priv->individual);
}
/* Add the new individual */
if (individual != NULL)
{
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
g_object_ref (individual);
(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));
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
+ {
+ FolksPersona *persona = gee_iterator_get (iter);
+ add_persona_and_connect (self, persona);
+ g_clear_object (&persona);
+ }
+ g_clear_object (&iter);
}
g_object_notify (G_OBJECT (self), "individual");
GPtrArray *words)
{
const gchar *str;
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
+ gboolean retval = FALSE;
/* check alias name */
str = folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (individual));
personas = folks_individual_get_personas (individual);
/* check contact id, remove the @server.com part */
- for (l = personas; l; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (retval == FALSE && gee_iterator_next (iter))
{
+ FolksPersona *persona = gee_iterator_get (iter);
const gchar *p;
- gchar *dup_str = NULL;
- gboolean visible;
- if (!empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
- continue;
-
- str = folks_persona_get_display_id (l->data);
-
- /* 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))
- return TRUE;
-
- p = strstr (str, "@");
- if (p != NULL)
- str = dup_str = g_strndup (str, p - str);
-
- visible = empathy_live_search_match_words (str, words);
- g_free (dup_str);
- if (visible)
- return TRUE;
+ 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 = empathy_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 FALSE;
+ return retval;
}
for (l = individuals; l != NULL; l = l->next)
{
- GList *personas, *j;
FolksIndividual *individual = FOLKS_INDIVIDUAL (l->data);
+ GeeSet *personas;
+ GeeIterator *iter;
+ gboolean persona_found = FALSE;
personas = folks_individual_get_personas (individual);
- for (j = personas; j != NULL; j = j->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (!persona_found && gee_iterator_next (iter))
{
- TpfPersona *persona = j->data;
+ TpfPersona *persona = gee_iterator_get (iter);
if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
{
/* Found the right persona */
empathy_contact_set_persona (contact,
(FolksPersona *) persona);
- goto finished;
+ persona_found = TRUE;
}
+ g_clear_object (&persona);
}
}
+ g_clear_object (&iter);
}
-finished:
g_list_free (individuals);
g_object_unref (manager);
}
empathy_contact_dup_best_for_action (FolksIndividual *individual,
EmpathyActionType action_type)
{
- GList *personas, *contacts, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
+ GList *contacts;
EmpathyContact *best_contact = NULL;
/* Build a list of EmpathyContacts that we can sort */
personas = folks_individual_get_personas (individual);
contacts = NULL;
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
+ FolksPersona *persona = gee_iterator_get (iter);
TpContact *tp_contact;
- EmpathyContact *contact;
+ EmpathyContact *contact = NULL;
- if (!empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
- continue;
+ if (!empathy_folks_persona_is_interesting (persona))
+ goto while_finish;
- tp_contact = tpf_persona_get_contact (TPF_PERSONA (l->data));
+ tp_contact = tpf_persona_get_contact (TPF_PERSONA (persona));
contact = empathy_contact_dup_from_tp_contact (tp_contact);
- empathy_contact_set_persona (contact, FOLKS_PERSONA (l->data));
+ empathy_contact_set_persona (contact, FOLKS_PERSONA (persona));
/* Only choose the contact if they're actually capable of the specified
* action. */
- if (!empathy_contact_can_do_action (contact, action_type))
- {
- g_object_unref (contact);
- continue;
- }
+ if (empathy_contact_can_do_action (contact, action_type))
+ contacts = g_list_prepend (contacts, g_object_ref (contact));
- contacts = g_list_prepend (contacts, contact);
+while_finish:
+ g_clear_object (&contact);
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
/* Sort the contacts by some heuristic based on the action type, then take
* the top contact. */
empathy_individual_manager_supports_blocking (EmpathyIndividualManager *self,
FolksIndividual *individual)
{
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
+ gboolean retval = FALSE;
g_return_val_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self), FALSE);
personas = folks_individual_get_personas (individual);
-
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (!retval && gee_iterator_next (iter))
{
- TpfPersona *persona = l->data;
+ TpfPersona *persona = gee_iterator_get (iter);
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 (TPF_IS_PERSONA (persona))
+ {
+ 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;
+ if (empathy_contact_manager_get_flags_for_connection (manager, conn) &
+ EMPATHY_CONTACT_LIST_CAN_BLOCK)
+ retval = TRUE;
- g_object_unref (manager);
+ g_object_unref (manager);
+ }
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
- return FALSE;
+ return retval;
}
void
gboolean blocked,
gboolean abusive)
{
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
g_return_if_fail (EMPATHY_IS_INDIVIDUAL_MANAGER (self));
personas = folks_individual_get_personas (individual);
-
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter))
{
- TpfPersona *persona = l->data;
+ TpfPersona *persona = gee_iterator_get (iter);
EmpathyContact *contact;
EmpathyContactManager *manager;
EmpathyContactListFlags flags;
- 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 ();
- flags = empathy_contact_manager_get_flags_for_connection (manager,
- empathy_contact_get_connection (contact));
-
- if (flags & EMPATHY_CONTACT_LIST_CAN_BLOCK)
- empathy_contact_list_set_blocked (
- EMPATHY_CONTACT_LIST (manager),
- contact, blocked, abusive);
-
- g_object_unref (manager);
- g_object_unref (contact);
+ if (TPF_IS_PERSONA (persona))
+ {
+ 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 ();
+ flags = empathy_contact_manager_get_flags_for_connection (manager,
+ empathy_contact_get_connection (contact));
+
+ if (flags & EMPATHY_CONTACT_LIST_CAN_BLOCK)
+ empathy_contact_list_set_blocked (
+ EMPATHY_CONTACT_LIST (manager),
+ contact, blocked, abusive);
+
+ g_object_unref (manager);
+ g_object_unref (contact);
+ }
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
}
static void
void
empathy_individual_manager_link_personas (EmpathyIndividualManager *self,
- GList *personas)
+ GeeSet *personas)
{
EmpathyIndividualManagerPriv *priv;
priv = GET_PRIV (self);
- DEBUG ("Linking %u personas", g_list_length (personas));
+ DEBUG ("Linking %u personas",
+ gee_collection_get_size (GEE_COLLECTION (personas)));
folks_individual_aggregator_link_personas (priv->aggregator, personas,
(GAsyncReadyCallback) link_personas_cb, NULL);
const gchar *group);
void empathy_individual_manager_link_personas (EmpathyIndividualManager *self,
- GList *personas);
+ GeeSet *personas);
void empathy_individual_manager_unlink_individual (
EmpathyIndividualManager *self,
gboolean
empathy_folks_individual_contains_contact (FolksIndividual *individual)
{
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
+ gboolean retval = FALSE;
g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), FALSE);
personas = folks_individual_get_personas (individual);
- for (l = personas; l != NULL; l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (!retval && gee_iterator_next (iter))
{
- if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (l->data)))
- return (tpf_persona_get_contact (TPF_PERSONA (l->data)) != NULL);
+ 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 FALSE;
+ return retval;
}
/* TODO: this needs to be eliminated (and replaced in some cases with user
EmpathyContact *
empathy_contact_dup_from_folks_individual (FolksIndividual *individual)
{
- GList *personas, *l;
+ GeeSet *personas;
+ GeeIterator *iter;
EmpathyContact *contact = NULL;
g_return_val_if_fail (FOLKS_IS_INDIVIDUAL (individual), NULL);
personas = folks_individual_get_personas (individual);
- for (l = personas; (l != NULL) && (contact == NULL); l = l->next)
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (gee_iterator_next (iter) && (contact == NULL))
{
- TpfPersona *persona = l->data;
+ TpfPersona *persona = gee_iterator_get (iter);
if (empathy_folks_persona_is_interesting (FOLKS_PERSONA (persona)))
{
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);
return contact;
}
}
TpfPersonaStore *
-empathy_get_persona_store_for_connection (TpConnection *connection)
+empathy_dup_persona_store_for_connection (TpConnection *connection)
{
FolksBackendStore *backend_store;
FolksBackend *backend;
gboolean
empathy_connection_can_add_personas (TpConnection *connection)
{
+ gboolean retval;
FolksPersonaStore *persona_store;
g_return_val_if_fail (TP_IS_CONNECTION (connection), FALSE);
persona_store = FOLKS_PERSONA_STORE (
- empathy_get_persona_store_for_connection (connection));
+ empathy_dup_persona_store_for_connection (connection));
- return (folks_persona_store_get_can_add_personas (persona_store) ==
+ retval = (folks_persona_store_get_can_add_personas (persona_store) ==
FOLKS_MAYBE_BOOL_TRUE);
+
+ g_clear_object (&persona_store);
+
+ return retval;
}
gboolean
empathy_connection_can_alias_personas (TpConnection *connection)
{
+ gboolean retval;
FolksPersonaStore *persona_store;
g_return_val_if_fail (TP_IS_CONNECTION (connection), FALSE);
persona_store = FOLKS_PERSONA_STORE (
- empathy_get_persona_store_for_connection (connection));
+ empathy_dup_persona_store_for_connection (connection));
- return (folks_persona_store_get_can_alias_personas (persona_store) ==
+ retval = (folks_persona_store_get_can_alias_personas (persona_store) ==
FOLKS_MAYBE_BOOL_TRUE);
+
+ g_clear_object (&persona_store);
+
+ return retval;
}
gboolean
empathy_connection_can_group_personas (TpConnection *connection)
{
+ gboolean retval;
FolksPersonaStore *persona_store;
g_return_val_if_fail (TP_IS_CONNECTION (connection), FALSE);
persona_store = FOLKS_PERSONA_STORE (
- empathy_get_persona_store_for_connection (connection));
+ empathy_dup_persona_store_for_connection (connection));
- return (folks_persona_store_get_can_group_personas (persona_store) ==
+ retval = (folks_persona_store_get_can_group_personas (persona_store) ==
FOLKS_MAYBE_BOOL_TRUE);
+
+ g_clear_object (&persona_store);
+
+ return retval;
}
gboolean
gboolean empathy_folks_individual_contains_contact (FolksIndividual *individual);
EmpathyContact * empathy_contact_dup_from_folks_individual (FolksIndividual *individual);
TpChannelGroupChangeReason tp_channel_group_change_reason_from_folks_groups_change_reason (FolksGroupDetailsChangeReason reason);
-TpfPersonaStore * empathy_get_persona_store_for_connection (TpConnection *connection);
+TpfPersonaStore * empathy_dup_persona_store_for_connection (TpConnection *connection);
gboolean empathy_connection_can_add_personas (TpConnection *connection);
gboolean empathy_connection_can_alias_personas (TpConnection *connection);
gboolean empathy_connection_can_group_personas (TpConnection *connection);
get_tp_contact_for_chat (EmpathyInviteParticipantDialog *self,
FolksIndividual *individual)
{
- GList *personas, *l;
+ TpContact *contact = NULL;
TpConnection *chat_conn;
+ GeeSet *personas;
+ GeeIterator *iter;
chat_conn = tp_channel_borrow_connection ((TpChannel *) self->priv->tp_chat);
personas = folks_individual_get_personas (individual);
-
- for (l = personas; l != NULL; l = g_list_next (l))
+ iter = gee_iterable_iterator (GEE_ITERABLE (personas));
+ while (contact == FALSE && gee_iterator_next (iter))
{
- TpfPersona *persona = l->data;
- TpContact *contact;
+ TpfPersona *persona = gee_iterator_get (iter);
TpConnection *contact_conn;
+ TpContact *contact_cur = NULL;
- if (!TPF_IS_PERSONA (persona))
- continue;
-
- contact = tpf_persona_get_contact (persona);
- if (contact == NULL)
- continue;
-
- contact_conn = tp_contact_get_connection (contact);
+ 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 (chat_conn)))
+ contact = contact_cur;
+ }
+ }
- if (!tp_strdiff (tp_proxy_get_object_path (contact_conn),
- tp_proxy_get_object_path (chat_conn)))
- return contact;
+ g_clear_object (&persona);
}
+ g_clear_object (&iter);
- return NULL;
+ return contact;
}
static gboolean
projects / empathy.git / commitdiff