X-Git-Url: https://git.0d.be/?p=empathy.git;a=blobdiff_plain;f=libempathy-gtk%2Fempathy-contact-list-store.c;h=359e6c1b60100999ae1425c97e1d3594c56c781e;hp=0e9372be189bbb9fbea268995748fb7c2481630e;hb=1c51f65b87f5b523e6fdc76b91402936e9599cff;hpb=5af5dedd2bd5a57f700d3abf7a326d0462494caa diff --git a/libempathy-gtk/empathy-contact-list-store.c b/libempathy-gtk/empathy-contact-list-store.c index 0e9372be..359e6c1b 100644 --- a/libempathy-gtk/empathy-contact-list-store.c +++ b/libempathy-gtk/empathy-contact-list-store.c @@ -28,14 +28,20 @@ #include #include +#include #include #include #include +#include +#include +#include + #include "empathy-contact-list-store.h" #include "empathy-ui-utils.h" #include "empathy-gtk-enum-types.h" +#include "empathy-images.h" #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT #include @@ -57,30 +63,27 @@ typedef struct { gboolean show_avatars; gboolean show_groups; gboolean is_compact; + gboolean show_protocols; gboolean show_active; EmpathyContactListStoreSort sort_criterium; guint inhibit_active; + guint setup_idle_id; + gboolean dispose_has_run; + GHashTable *status_icons; + /* Hash: EmpathyContact* -> GQueue (GtkTreeIter *) */ + GHashTable *empathy_contact_cache; + /* Hash: char *groupname -> GtkTreeIter * */ + GHashTable *empathy_group_cache; } EmpathyContactListStorePriv; -typedef struct { - GtkTreeIter iter; - const gchar *name; - gboolean found; -} FindGroup; - -typedef struct { - EmpathyContact *contact; - gboolean found; - GList *iters; -} FindContact; - typedef struct { EmpathyContactListStore *store; EmpathyContact *contact; gboolean remove; + guint timeout; } ShowActiveData; -static void contact_list_store_finalize (GObject *object); +static void contact_list_store_dispose (GObject *object); static void contact_list_store_get_property (GObject *object, guint param_id, GValue *value, @@ -98,6 +101,12 @@ static void contact_list_store_members_changed_cb (EmpathyCon gchar *message, gboolean is_member, EmpathyContactListStore *store); +static void contact_list_store_member_renamed_cb (EmpathyContactList *list_iface, + EmpathyContact *old_contact, + EmpathyContact *new_contact, + guint reason, + gchar *message, + EmpathyContactListStore *store); static void contact_list_store_groups_changed_cb (EmpathyContactList *list_iface, EmpathyContact *contact, gchar *group, @@ -121,15 +130,12 @@ static ShowActiveData * contact_list_store_contact_active_new (EmpathyCon gboolean remove); static void contact_list_store_contact_active_free (ShowActiveData *data); static gboolean contact_list_store_contact_active_cb (ShowActiveData *data); -static gboolean contact_list_store_get_group_foreach (GtkTreeModel *model, - GtkTreePath *path, - GtkTreeIter *iter, - FindGroup *fg); static void contact_list_store_get_group (EmpathyContactListStore *store, const gchar *name, GtkTreeIter *iter_group_to_set, GtkTreeIter *iter_separator_to_set, - gboolean *created); + gboolean *created, + gboolean is_fake_group); static gint contact_list_store_state_sort_func (GtkTreeModel *model, GtkTreeIter *iter_a, GtkTreeIter *iter_b, @@ -138,10 +144,6 @@ static gint contact_list_store_name_sort_func (GtkTreeMod GtkTreeIter *iter_a, GtkTreeIter *iter_b, gpointer user_data); -static gboolean contact_list_store_find_contact_foreach (GtkTreeModel *model, - GtkTreePath *path, - GtkTreeIter *iter, - FindContact *fc); static GList * contact_list_store_find_contact (EmpathyContactListStore *store, EmpathyContact *contact); static gboolean contact_list_store_update_list_mode_foreach (GtkTreeModel *model, @@ -154,6 +156,7 @@ enum { PROP_CONTACT_LIST, PROP_SHOW_OFFLINE, PROP_SHOW_AVATARS, + PROP_SHOW_PROTOCOLS, PROP_SHOW_GROUPS, PROP_IS_COMPACT, PROP_SORT_CRITERIUM @@ -161,6 +164,30 @@ enum { G_DEFINE_TYPE (EmpathyContactListStore, empathy_contact_list_store, GTK_TYPE_TREE_STORE); +static void +contact_list_store_chat_state_changed_cb (TpChannel *self, + guint contact_handle, + guint state, + gpointer store) +{ + EmpathyContactListStorePriv *priv = GET_PRIV (store); + GList *contacts, *l; + + contacts = empathy_contact_list_get_members (priv->list); + + for (l = contacts; l != NULL; l = l->next) { + EmpathyContact *contact = EMPATHY_CONTACT (l->data); + + if (empathy_contact_get_handle (contact) == contact_handle) { + contact_list_store_contact_update (store, contact); + break; + } + } + + g_list_foreach (contacts, (GFunc) g_object_unref, NULL); + g_list_free (contacts); +} + static gboolean contact_list_store_iface_setup (gpointer user_data) { @@ -169,6 +196,10 @@ contact_list_store_iface_setup (gpointer user_data) GList *contacts, *l; /* Signal connection. */ + g_signal_connect (priv->list, + "member-renamed", + G_CALLBACK (contact_list_store_member_renamed_cb), + store); g_signal_connect (priv->list, "members-changed", G_CALLBACK (contact_list_store_members_changed_cb), @@ -178,6 +209,13 @@ contact_list_store_iface_setup (gpointer user_data) G_CALLBACK (contact_list_store_groups_changed_cb), store); + if (EMPATHY_IS_TP_CHAT (priv->list)) { + g_signal_connect (priv->list, + "chat-state-changed", + G_CALLBACK (contact_list_store_chat_state_changed_cb), + store); + } + /* Add contacts already created. */ contacts = empathy_contact_list_get_members (priv->list); for (l = contacts; l; l = l->next) { @@ -190,6 +228,7 @@ contact_list_store_iface_setup (gpointer user_data) } g_list_free (contacts); + priv->setup_idle_id = 0; return FALSE; } @@ -203,7 +242,7 @@ contact_list_store_set_contact_list (EmpathyContactListStore *store, priv->list = g_object_ref (list_iface); /* Let a chance to have all properties set before populating */ - g_idle_add (contact_list_store_iface_setup, store); + priv->setup_idle_id = g_idle_add (contact_list_store_iface_setup, store); } static void @@ -211,7 +250,7 @@ empathy_contact_list_store_class_init (EmpathyContactListStoreClass *klass) { GObjectClass *object_class = G_OBJECT_CLASS (klass); - object_class->finalize = contact_list_store_finalize; + object_class->dispose = contact_list_store_dispose; object_class->get_property = contact_list_store_get_property; object_class->set_property = contact_list_store_set_property; @@ -239,6 +278,14 @@ empathy_contact_list_store_class_init (EmpathyContactListStoreClass *klass) "avatars for contacts", TRUE, G_PARAM_READWRITE)); + g_object_class_install_property (object_class, + PROP_SHOW_PROTOCOLS, + g_param_spec_boolean ("show-protocols", + "Show Protocols", + "Whether contact list should display " + "protocols for contacts", + FALSE, + G_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_SHOW_GROUPS, g_param_spec_boolean ("show-groups", @@ -267,6 +314,15 @@ empathy_contact_list_store_class_init (EmpathyContactListStoreClass *klass) g_type_class_add_private (object_class, sizeof (EmpathyContactListStorePriv)); } +static void +g_queue_free_full_iter (gpointer data) +{ + GQueue *queue = (GQueue *) data; + g_queue_foreach (queue, (GFunc) gtk_tree_iter_free, NULL); + g_queue_free (queue); +} + + static void empathy_contact_list_store_init (EmpathyContactListStore *store) { @@ -276,18 +332,29 @@ empathy_contact_list_store_init (EmpathyContactListStore *store) store->priv = priv; priv->show_avatars = TRUE; priv->show_groups = TRUE; + priv->show_protocols = FALSE; priv->inhibit_active = g_timeout_add_seconds (ACTIVE_USER_WAIT_TO_ENABLE_TIME, (GSourceFunc) contact_list_store_inibit_active_cb, store); + priv->status_icons = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref); + priv->empathy_contact_cache = g_hash_table_new_full (NULL, NULL, NULL, + g_queue_free_full_iter); + priv->empathy_group_cache = g_hash_table_new_full (g_str_hash, + g_str_equal, g_free, + (GDestroyNotify) gtk_tree_iter_free); contact_list_store_setup (store); } static void -contact_list_store_finalize (GObject *object) +contact_list_store_dispose (GObject *object) { EmpathyContactListStorePriv *priv = GET_PRIV (object); GList *contacts, *l; + if (priv->dispose_has_run) + return; + priv->dispose_has_run = TRUE; + contacts = empathy_contact_list_get_members (priv->list); for (l = contacts; l; l = l->next) { g_signal_handlers_disconnect_by_func (l->data, @@ -298,6 +365,9 @@ contact_list_store_finalize (GObject *object) } g_list_free (contacts); + g_signal_handlers_disconnect_by_func (priv->list, + G_CALLBACK (contact_list_store_member_renamed_cb), + object); g_signal_handlers_disconnect_by_func (priv->list, G_CALLBACK (contact_list_store_members_changed_cb), object); @@ -306,11 +376,20 @@ contact_list_store_finalize (GObject *object) object); g_object_unref (priv->list); - if (priv->inhibit_active) { + if (priv->inhibit_active != 0) { g_source_remove (priv->inhibit_active); + priv->inhibit_active = 0; + } + + if (priv->setup_idle_id != 0) { + g_source_remove (priv->setup_idle_id); + priv->setup_idle_id = 0; } - G_OBJECT_CLASS (empathy_contact_list_store_parent_class)->finalize (object); + g_hash_table_unref (priv->status_icons); + g_hash_table_unref (priv->empathy_contact_cache); + g_hash_table_unref (priv->empathy_group_cache); + G_OBJECT_CLASS (empathy_contact_list_store_parent_class)->dispose (object); } static void @@ -333,6 +412,9 @@ contact_list_store_get_property (GObject *object, case PROP_SHOW_AVATARS: g_value_set_boolean (value, priv->show_avatars); break; + case PROP_SHOW_PROTOCOLS: + g_value_set_boolean (value, priv->show_protocols); + break; case PROP_SHOW_GROUPS: g_value_set_boolean (value, priv->show_groups); break; @@ -354,10 +436,6 @@ contact_list_store_set_property (GObject *object, const GValue *value, GParamSpec *pspec) { - EmpathyContactListStorePriv *priv; - - priv = GET_PRIV (object); - switch (param_id) { case PROP_CONTACT_LIST: contact_list_store_set_contact_list (EMPATHY_CONTACT_LIST_STORE (object), @@ -371,6 +449,10 @@ contact_list_store_set_property (GObject *object, empathy_contact_list_store_set_show_avatars (EMPATHY_CONTACT_LIST_STORE (object), g_value_get_boolean (value)); break; + case PROP_SHOW_PROTOCOLS: + empathy_contact_list_store_set_show_protocols (EMPATHY_CONTACT_LIST_STORE (object), + g_value_get_boolean (value)); + break; case PROP_SHOW_GROUPS: empathy_contact_list_store_set_show_groups (EMPATHY_CONTACT_LIST_STORE (object), g_value_get_boolean (value)); @@ -490,6 +572,42 @@ empathy_contact_list_store_set_show_avatars (EmpathyContactListStore *store, g_object_notify (G_OBJECT (store), "show-avatars"); } + +gboolean +empathy_contact_list_store_get_show_protocols (EmpathyContactListStore *store) +{ + EmpathyContactListStorePriv *priv; + + g_return_val_if_fail (EMPATHY_IS_CONTACT_LIST_STORE (store), TRUE); + + priv = GET_PRIV (store); + + return priv->show_protocols; +} + +void +empathy_contact_list_store_set_show_protocols (EmpathyContactListStore *store, + gboolean show_protocols) +{ + EmpathyContactListStorePriv *priv; + GtkTreeModel *model; + + g_return_if_fail (EMPATHY_IS_CONTACT_LIST_STORE (store)); + + priv = GET_PRIV (store); + + priv->show_protocols = show_protocols; + + model = GTK_TREE_MODEL (store); + + gtk_tree_model_foreach (model, + (GtkTreeModelForeachFunc) + contact_list_store_update_list_mode_foreach, + store); + + g_object_notify (G_OBJECT (store), "show-protocols"); +} + gboolean empathy_contact_list_store_get_show_groups (EmpathyContactListStore *store) { @@ -507,7 +625,6 @@ empathy_contact_list_store_set_show_groups (EmpathyContactListStore *store, gboolean show_groups) { EmpathyContactListStorePriv *priv; - GList *contacts, *l; g_return_if_fail (EMPATHY_IS_CONTACT_LIST_STORE (store)); @@ -519,19 +636,33 @@ empathy_contact_list_store_set_show_groups (EmpathyContactListStore *store, priv->show_groups = show_groups; - /* Remove all contacts and add them back, not optimized but that's the - * easy way :) */ - gtk_tree_store_clear (GTK_TREE_STORE (store)); - contacts = empathy_contact_list_get_members (priv->list); - for (l = contacts; l; l = l->next) { - contact_list_store_members_changed_cb (priv->list, l->data, - NULL, 0, NULL, - TRUE, - store); - - g_object_unref (l->data); + if (priv->setup_idle_id == 0) { + /* Remove all contacts and add them back, not optimized but + * that's the easy way :) + * + * This is only done if there's not a pending setup idle + * callback, otherwise it will race and the contacts will get + * added twice */ + GList *contacts, *l; + + gtk_tree_store_clear (GTK_TREE_STORE (store)); + + /* Also clear the cache */ + g_hash_table_remove_all (priv->empathy_contact_cache); + g_hash_table_remove_all (priv->empathy_group_cache); + + contacts = empathy_contact_list_get_members (priv->list); + for (l = contacts; l; l = l->next) { + contact_list_store_members_changed_cb (priv->list, + l->data, + NULL, 0, NULL, + TRUE, + store); + + g_object_unref (l->data); + } + g_list_free (contacts); } - g_list_free (contacts); g_object_notify (G_OBJECT (store), "show-groups"); } @@ -607,6 +738,9 @@ empathy_contact_list_store_set_sort_criterium (EmpathyContactListStore *stor EMPATHY_CONTACT_LIST_STORE_COL_NAME, GTK_SORT_ASCENDING); break; + + default: + g_assert_not_reached (); } g_object_notify (G_OBJECT (store), "sort-criterium"); @@ -631,11 +765,13 @@ empathy_contact_list_store_row_separator_func (GtkTreeModel *model, gchar * empathy_contact_list_store_get_parent_group (GtkTreeModel *model, GtkTreePath *path, - gboolean *path_is_group) + gboolean *path_is_group, + gboolean *is_fake_group) { GtkTreeIter parent_iter, iter; gchar *name = NULL; gboolean is_group; + gboolean fake; g_return_val_if_fail (GTK_IS_TREE_MODEL (model), NULL); @@ -665,6 +801,7 @@ empathy_contact_list_store_get_parent_group (GtkTreeModel *model, gtk_tree_model_get (model, &iter, EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group, EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name, + EMPATHY_CONTACT_LIST_STORE_COL_IS_FAKE_GROUP, &fake, -1); if (!is_group) { g_free (name); @@ -676,68 +813,34 @@ empathy_contact_list_store_get_parent_group (GtkTreeModel *model, *path_is_group = TRUE; } - return name; -} - -gboolean -empathy_contact_list_store_search_equal_func (GtkTreeModel *model, - gint column, - const gchar *key, - GtkTreeIter *iter, - gpointer search_data) -{ - gchar *name, *name_folded; - gchar *key_folded; - gboolean ret; - - g_return_val_if_fail (GTK_IS_TREE_MODEL (model), FALSE); - - if (!key) { - return TRUE; - } - - gtk_tree_model_get (model, iter, - EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name, - -1); - - if (!name) { - return TRUE; - } - - name_folded = g_utf8_casefold (name, -1); - key_folded = g_utf8_casefold (key, -1); + if (is_fake_group != NULL) + *is_fake_group = fake; - if (name_folded && key_folded && - strstr (name_folded, key_folded)) { - ret = FALSE; - } else { - ret = TRUE; - } - - g_free (name); - g_free (name_folded); - g_free (key_folded); - - return ret; + return name; } static void contact_list_store_setup (EmpathyContactListStore *store) { EmpathyContactListStorePriv *priv; - GType types[] = {G_TYPE_STRING, /* Status icon-name */ - GDK_TYPE_PIXBUF, /* Avatar pixbuf */ - G_TYPE_BOOLEAN, /* Avatar pixbuf visible */ - G_TYPE_STRING, /* Name */ - G_TYPE_STRING, /* Status string */ - G_TYPE_BOOLEAN, /* Show status */ - EMPATHY_TYPE_CONTACT, /* Contact type */ - G_TYPE_BOOLEAN, /* Is group */ - G_TYPE_BOOLEAN, /* Is active */ - G_TYPE_BOOLEAN, /* Is online */ - G_TYPE_BOOLEAN, /* Is separator */ - G_TYPE_BOOLEAN, /* Can make audio calls */ - G_TYPE_BOOLEAN}; /* Can make video calls */ + GType types[] = { + GDK_TYPE_PIXBUF, /* Status pixbuf */ + GDK_TYPE_PIXBUF, /* Avatar pixbuf */ + G_TYPE_BOOLEAN, /* Avatar pixbuf visible */ + G_TYPE_STRING, /* Name */ + G_TYPE_UINT, /* Presence type */ + G_TYPE_STRING, /* Status string */ + G_TYPE_BOOLEAN, /* Compact view */ + EMPATHY_TYPE_CONTACT, /* Contact type */ + G_TYPE_BOOLEAN, /* Is group */ + G_TYPE_BOOLEAN, /* Is active */ + G_TYPE_BOOLEAN, /* Is online */ + G_TYPE_BOOLEAN, /* Is separator */ + G_TYPE_BOOLEAN, /* Can make audio calls */ + G_TYPE_BOOLEAN, /* Can make video calls */ + EMPATHY_TYPE_CONTACT_LIST_FLAGS, /* Flags */ + G_TYPE_BOOLEAN, /* Is a fake group */ + }; priv = GET_PRIV (store); @@ -772,6 +875,38 @@ contact_list_store_inibit_active_cb (EmpathyContactListStore *store) return FALSE; } +static void +contact_list_store_add_contact_and_connect (EmpathyContactListStore *store, EmpathyContact *contact) +{ + g_signal_connect (contact, "notify::presence", + G_CALLBACK (contact_list_store_contact_updated_cb), + store); + g_signal_connect (contact, "notify::presence-message", + G_CALLBACK (contact_list_store_contact_updated_cb), + store); + g_signal_connect (contact, "notify::name", + G_CALLBACK (contact_list_store_contact_updated_cb), + store); + g_signal_connect (contact, "notify::avatar", + G_CALLBACK (contact_list_store_contact_updated_cb), + store); + g_signal_connect (contact, "notify::capabilities", + G_CALLBACK (contact_list_store_contact_updated_cb), + store); + + contact_list_store_add_contact (store, contact); +} + +static void +contact_list_store_remove_contact_and_disconnect (EmpathyContactListStore *store, EmpathyContact *contact) +{ + g_signal_handlers_disconnect_by_func (contact, + G_CALLBACK (contact_list_store_contact_updated_cb), + store); + + contact_list_store_remove_contact (store, contact); +} + static void contact_list_store_members_changed_cb (EmpathyContactList *list_iface, EmpathyContact *contact, @@ -781,42 +916,39 @@ contact_list_store_members_changed_cb (EmpathyContactList *list_iface, gboolean is_member, EmpathyContactListStore *store) { - EmpathyContactListStorePriv *priv; - - priv = GET_PRIV (store); - DEBUG ("Contact %s (%d) %s", empathy_contact_get_id (contact), empathy_contact_get_handle (contact), is_member ? "added" : "removed"); if (is_member) { - g_signal_connect (contact, "notify::presence", - G_CALLBACK (contact_list_store_contact_updated_cb), - store); - g_signal_connect (contact, "notify::presence-message", - G_CALLBACK (contact_list_store_contact_updated_cb), - store); - g_signal_connect (contact, "notify::name", - G_CALLBACK (contact_list_store_contact_updated_cb), - store); - g_signal_connect (contact, "notify::avatar", - G_CALLBACK (contact_list_store_contact_updated_cb), - store); - g_signal_connect (contact, "notify::capabilities", - G_CALLBACK (contact_list_store_contact_updated_cb), - store); - - contact_list_store_add_contact (store, contact); + contact_list_store_add_contact_and_connect (store, contact); } else { - g_signal_handlers_disconnect_by_func (contact, - G_CALLBACK (contact_list_store_contact_updated_cb), - store); - - contact_list_store_remove_contact (store, contact); + contact_list_store_remove_contact_and_disconnect (store, contact); } } +static void +contact_list_store_member_renamed_cb (EmpathyContactList *list_iface, + EmpathyContact *old_contact, + EmpathyContact *new_contact, + guint reason, + gchar *message, + EmpathyContactListStore *store) +{ + DEBUG ("Contact %s (%d) renamed to %s (%d)", + empathy_contact_get_id (old_contact), + empathy_contact_get_handle (old_contact), + empathy_contact_get_id (new_contact), + empathy_contact_get_handle (new_contact)); + + /* add the new contact */ + contact_list_store_add_contact_and_connect (store, new_contact); + + /* remove old contact */ + contact_list_store_remove_contact_and_disconnect (store, old_contact); +} + static void contact_list_store_groups_changed_cb (EmpathyContactList *list_iface, EmpathyContact *contact, @@ -844,6 +976,41 @@ contact_list_store_groups_changed_cb (EmpathyContactList *list_iface, priv->show_active = show_active; } +static void +add_contact_to_store (GtkTreeStore *store, + GtkTreeIter *iter, + GtkTreeIter *parent, + EmpathyContact *contact, + EmpathyContactListFlags flags) +{ + EmpathyContactListStorePriv *priv = GET_PRIV (store); + GQueue *queue; + + gtk_tree_store_insert_with_values (store, iter, parent, 0, + EMPATHY_CONTACT_LIST_STORE_COL_NAME, empathy_contact_get_alias (contact), + EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, contact, + EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, FALSE, + EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, FALSE, + EMPATHY_CONTACT_LIST_STORE_COL_CAN_AUDIO_CALL, + empathy_contact_get_capabilities (contact) & + EMPATHY_CAPABILITIES_AUDIO, + EMPATHY_CONTACT_LIST_STORE_COL_CAN_VIDEO_CALL, + empathy_contact_get_capabilities (contact) & + EMPATHY_CAPABILITIES_VIDEO, + EMPATHY_CONTACT_LIST_STORE_COL_FLAGS, flags, + -1); + + queue = g_hash_table_lookup (priv->empathy_contact_cache, contact); + if (queue) { + g_queue_push_tail (queue, gtk_tree_iter_copy (iter)); + } else { + queue = g_queue_new (); + g_queue_push_tail (queue, gtk_tree_iter_copy (iter)); + g_hash_table_insert (priv->empathy_contact_cache, contact, + queue); + } +} + static void contact_list_store_add_contact (EmpathyContactListStore *store, EmpathyContact *contact) @@ -851,10 +1018,13 @@ contact_list_store_add_contact (EmpathyContactListStore *store, EmpathyContactListStorePriv *priv; GtkTreeIter iter; GList *groups = NULL, *l; + TpConnection *connection; + EmpathyContactListFlags flags = 0; + char *protocol_name; priv = GET_PRIV (store); - if (EMP_STR_EMPTY (empathy_contact_get_name (contact)) || + if (EMP_STR_EMPTY (empathy_contact_get_alias (contact)) || (!priv->show_offline && !empathy_contact_is_online (contact))) { return; } @@ -863,86 +1033,83 @@ contact_list_store_add_contact (EmpathyContactListStore *store, groups = empathy_contact_list_get_groups (priv->list, contact); } - /* If no groups just add it at the top level. */ + connection = empathy_contact_get_connection (contact); + if (EMPATHY_IS_CONTACT_MANAGER (priv->list)) { + flags = empathy_contact_manager_get_flags_for_connection ( + EMPATHY_CONTACT_MANAGER (priv->list), connection); + } + + tp_connection_parse_object_path (connection, &protocol_name, NULL); + if (!groups) { - gtk_tree_store_append (GTK_TREE_STORE (store), &iter, NULL); - gtk_tree_store_set (GTK_TREE_STORE (store), &iter, - EMPATHY_CONTACT_LIST_STORE_COL_NAME, empathy_contact_get_name (contact), - EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, contact, - EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, FALSE, - EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, FALSE, - EMPATHY_CONTACT_LIST_STORE_COL_CAN_AUDIO_CALL, - empathy_contact_get_capabilities (contact) & - EMPATHY_CAPABILITIES_AUDIO, - EMPATHY_CONTACT_LIST_STORE_COL_CAN_VIDEO_CALL, - empathy_contact_get_capabilities (contact) & - EMPATHY_CAPABILITIES_VIDEO, - -1); + GtkTreeIter iter_group, *parent; + + parent = &iter_group; + + if (!priv->show_groups) { + parent = NULL; + } + + add_contact_to_store (GTK_TREE_STORE (store), &iter, parent, + contact, flags); } + g_free (protocol_name); + /* Else add to each group. */ for (l = groups; l; l = l->next) { GtkTreeIter iter_group; - contact_list_store_get_group (store, l->data, &iter_group, NULL, NULL); + contact_list_store_get_group (store, l->data, &iter_group, NULL, NULL, FALSE); - gtk_tree_store_insert_after (GTK_TREE_STORE (store), &iter, - &iter_group, NULL); - gtk_tree_store_set (GTK_TREE_STORE (store), &iter, - EMPATHY_CONTACT_LIST_STORE_COL_NAME, empathy_contact_get_name (contact), - EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, contact, - EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, FALSE, - EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, FALSE, - EMPATHY_CONTACT_LIST_STORE_COL_CAN_AUDIO_CALL, - empathy_contact_get_capabilities (contact) & - EMPATHY_CAPABILITIES_AUDIO, - EMPATHY_CONTACT_LIST_STORE_COL_CAN_VIDEO_CALL, - empathy_contact_get_capabilities (contact) & - EMPATHY_CAPABILITIES_VIDEO, - -1); + add_contact_to_store (GTK_TREE_STORE (store), &iter, &iter_group, contact, flags); g_free (l->data); } g_list_free (groups); contact_list_store_contact_update (store, contact); - } static void contact_list_store_remove_contact (EmpathyContactListStore *store, EmpathyContact *contact) { - EmpathyContactListStorePriv *priv; + EmpathyContactListStorePriv *priv = GET_PRIV (store); GtkTreeModel *model; - GList *iters, *l; + GList *l; + GQueue *row_refs; - priv = GET_PRIV (store); - - iters = contact_list_store_find_contact (store, contact); - if (!iters) { + row_refs = g_hash_table_lookup (priv->empathy_contact_cache, contact); + if (!row_refs) { return; } /* Clean up model */ model = GTK_TREE_MODEL (store); - for (l = iters; l; l = l->next) { + for (l = g_queue_peek_head_link (row_refs); l; l = l->next) { + GtkTreeIter *iter = l->data; GtkTreeIter parent; /* NOTE: it is only <= 2 here because we have * separators after the group name, otherwise it * should be 1. */ - if (gtk_tree_model_iter_parent (model, &parent, l->data) && + if (gtk_tree_model_iter_parent (model, &parent, iter) && gtk_tree_model_iter_n_children (model, &parent) <= 2) { + gchar *group_name; + gtk_tree_model_get (model, &parent, + EMPATHY_CONTACT_LIST_STORE_COL_NAME, &group_name, + -1); + g_hash_table_remove (priv->empathy_group_cache, + group_name); gtk_tree_store_remove (GTK_TREE_STORE (store), &parent); } else { - gtk_tree_store_remove (GTK_TREE_STORE (store), l->data); + gtk_tree_store_remove (GTK_TREE_STORE (store), iter); } } - g_list_foreach (iters, (GFunc) gtk_tree_iter_free, NULL); - g_list_free (iters); + g_hash_table_remove (priv->empathy_contact_cache, contact); } static void @@ -963,6 +1130,7 @@ contact_list_store_contact_update (EmpathyContactListStore *store, gboolean do_set_refresh = FALSE; gboolean show_avatar = FALSE; GdkPixbuf *pixbuf_avatar; + GdkPixbuf *pixbuf_status; priv = GET_PRIV (store); @@ -987,7 +1155,7 @@ contact_list_store_contact_update (EmpathyContactListStore *store, if (!in_list && !should_be_in_list) { /* Nothing to do. */ DEBUG ("Contact:'%s' in list:NO, should be:NO", - empathy_contact_get_name (contact)); + empathy_contact_get_alias (contact)); g_list_foreach (iters, (GFunc) gtk_tree_iter_free, NULL); g_list_free (iters); @@ -995,7 +1163,7 @@ contact_list_store_contact_update (EmpathyContactListStore *store, } else if (in_list && !should_be_in_list) { DEBUG ("Contact:'%s' in list:YES, should be:NO", - empathy_contact_get_name (contact)); + empathy_contact_get_alias (contact)); if (priv->show_active) { do_remove = TRUE; @@ -1011,7 +1179,7 @@ contact_list_store_contact_update (EmpathyContactListStore *store, } else if (!in_list && should_be_in_list) { DEBUG ("Contact:'%s' in list:NO, should be:YES", - empathy_contact_get_name (contact)); + empathy_contact_get_alias (contact)); contact_list_store_add_contact (store, contact); @@ -1022,7 +1190,7 @@ contact_list_store_contact_update (EmpathyContactListStore *store, } } else { DEBUG ("Contact:'%s' in list:YES, should be:YES", - empathy_contact_get_name (contact)); + empathy_contact_get_alias (contact)); /* Get online state before. */ if (iters && g_list_length (iters) > 0) { @@ -1056,14 +1224,18 @@ contact_list_store_contact_update (EmpathyContactListStore *store, show_avatar = TRUE; } pixbuf_avatar = empathy_pixbuf_avatar_from_contact_scaled (contact, 32, 32); + pixbuf_status = contact_list_store_get_contact_status_icon (store, contact); for (l = iters; l && set_model; l = l->next) { gtk_tree_store_set (GTK_TREE_STORE (store), l->data, - EMPATHY_CONTACT_LIST_STORE_COL_ICON_STATUS, empathy_icon_name_for_contact (contact), + EMPATHY_CONTACT_LIST_STORE_COL_ICON_STATUS, pixbuf_status, EMPATHY_CONTACT_LIST_STORE_COL_PIXBUF_AVATAR, pixbuf_avatar, EMPATHY_CONTACT_LIST_STORE_COL_PIXBUF_AVATAR_VISIBLE, show_avatar, - EMPATHY_CONTACT_LIST_STORE_COL_NAME, empathy_contact_get_name (contact), - EMPATHY_CONTACT_LIST_STORE_COL_STATUS, empathy_contact_get_status (contact), - EMPATHY_CONTACT_LIST_STORE_COL_STATUS_VISIBLE, !priv->is_compact, + EMPATHY_CONTACT_LIST_STORE_COL_NAME, empathy_contact_get_alias (contact), + EMPATHY_CONTACT_LIST_STORE_COL_PRESENCE_TYPE, + empathy_contact_get_presence (contact), + EMPATHY_CONTACT_LIST_STORE_COL_STATUS, + empathy_contact_get_presence_message (contact), + EMPATHY_CONTACT_LIST_STORE_COL_COMPACT, priv->is_compact, EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_IS_ONLINE, now_online, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, FALSE, @@ -1085,7 +1257,7 @@ contact_list_store_contact_update (EmpathyContactListStore *store, if (do_set_active) { data = contact_list_store_contact_active_new (store, contact, do_remove); - g_timeout_add_seconds (ACTIVE_USER_SHOW_TIME, + data->timeout = g_timeout_add_seconds (ACTIVE_USER_SHOW_TIME, (GSourceFunc) contact_list_store_contact_active_cb, data); } @@ -1106,7 +1278,7 @@ contact_list_store_contact_updated_cb (EmpathyContact *contact, EmpathyContactListStore *store) { DEBUG ("Contact:'%s' updated, checking roster is in sync...", - empathy_contact_get_name (contact)); + empathy_contact_get_alias (contact)); contact_list_store_contact_update (store, contact); } @@ -1117,11 +1289,9 @@ contact_list_store_contact_set_active (EmpathyContactListStore *store, gboolean active, gboolean set_changed) { - EmpathyContactListStorePriv *priv; GtkTreeModel *model; GList *iters, *l; - priv = GET_PRIV (store); model = GTK_TREE_MODEL (store); iters = contact_list_store_find_contact (store, contact); @@ -1146,22 +1316,49 @@ contact_list_store_contact_set_active (EmpathyContactListStore *store, } +static void +store_contact_active_invalidated (ShowActiveData *data, + GObject *old_object) +{ + /* Remove the timeout and free the struct, since the contact or contact + * store has disappeared. */ + g_source_remove (data->timeout); + + if (old_object == (GObject *) data->store) + data->store = NULL; + else if (old_object == (GObject *) data->contact) + data->contact = NULL; + else + g_assert_not_reached (); + + contact_list_store_contact_active_free (data); +} + static ShowActiveData * contact_list_store_contact_active_new (EmpathyContactListStore *store, EmpathyContact *contact, - gboolean remove) + gboolean remove_) { ShowActiveData *data; DEBUG ("Contact:'%s' now active, and %s be removed", - empathy_contact_get_name (contact), - remove ? "WILL" : "WILL NOT"); + empathy_contact_get_alias (contact), + remove_ ? "WILL" : "WILL NOT"); data = g_slice_new0 (ShowActiveData); - data->store = g_object_ref (store); - data->contact = g_object_ref (contact); - data->remove = remove; + /* We don't actually want to force either the IndividualStore or the + * Individual to stay alive, since the user could quit Empathy or disable + * the account before the contact_active timeout is fired. */ + g_object_weak_ref (G_OBJECT (store), + (GWeakNotify) store_contact_active_invalidated, data); + g_object_weak_ref (G_OBJECT (contact), + (GWeakNotify) store_contact_active_invalidated, data); + + data->store = store; + data->contact = contact; + data->remove = remove_; + data->timeout = 0; return data; } @@ -1169,8 +1366,13 @@ contact_list_store_contact_active_new (EmpathyContactListStore *store, static void contact_list_store_contact_active_free (ShowActiveData *data) { - g_object_unref (data->contact); - g_object_unref (data->store); + if (data->store != NULL) + g_object_weak_unref (G_OBJECT (data->store), + (GWeakNotify) store_contact_active_invalidated, data); + + if (data->contact != NULL) + g_object_weak_unref (G_OBJECT (data->contact), + (GWeakNotify) store_contact_active_invalidated, data); g_slice_free (ShowActiveData, data); } @@ -1186,12 +1388,12 @@ contact_list_store_contact_active_cb (ShowActiveData *data) !priv->show_offline && !empathy_contact_is_online (data->contact)) { DEBUG ("Contact:'%s' active timeout, removing item", - empathy_contact_get_name (data->contact)); + empathy_contact_get_alias (data->contact)); contact_list_store_remove_contact (data->store, data->contact); } DEBUG ("Contact:'%s' no longer active", - empathy_contact_get_name (data->contact)); + empathy_contact_get_alias (data->contact)); contact_list_store_contact_set_active (data->store, data->contact, @@ -1203,81 +1405,45 @@ contact_list_store_contact_active_cb (ShowActiveData *data) return FALSE; } -static gboolean -contact_list_store_get_group_foreach (GtkTreeModel *model, - GtkTreePath *path, - GtkTreeIter *iter, - FindGroup *fg) -{ - gchar *str; - gboolean is_group; - - /* Groups are only at the top level. */ - if (gtk_tree_path_get_depth (path) != 1) { - return FALSE; - } - - gtk_tree_model_get (model, iter, - EMPATHY_CONTACT_LIST_STORE_COL_NAME, &str, - EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group, - -1); - - if (is_group && !tp_strdiff (str, fg->name)) { - fg->found = TRUE; - fg->iter = *iter; - } - - g_free (str); - - return fg->found; -} - static void contact_list_store_get_group (EmpathyContactListStore *store, const gchar *name, GtkTreeIter *iter_group_to_set, GtkTreeIter *iter_separator_to_set, - gboolean *created) + gboolean *created, + gboolean is_fake_group) { - EmpathyContactListStorePriv *priv; + EmpathyContactListStorePriv *priv = GET_PRIV (store); GtkTreeModel *model; GtkTreeIter iter_group; GtkTreeIter iter_separator; - FindGroup fg; - - priv = GET_PRIV (store); - - memset (&fg, 0, sizeof (fg)); - - fg.name = name; + GtkTreeIter *iter; model = GTK_TREE_MODEL (store); - gtk_tree_model_foreach (model, - (GtkTreeModelForeachFunc) contact_list_store_get_group_foreach, - &fg); + iter = g_hash_table_lookup (priv->empathy_group_cache, name); - if (!fg.found) { + if (iter == NULL) { if (created) { *created = TRUE; } - gtk_tree_store_append (GTK_TREE_STORE (store), &iter_group, NULL); - gtk_tree_store_set (GTK_TREE_STORE (store), &iter_group, + gtk_tree_store_insert_with_values (GTK_TREE_STORE (store), &iter_group, NULL, 0, EMPATHY_CONTACT_LIST_STORE_COL_ICON_STATUS, NULL, EMPATHY_CONTACT_LIST_STORE_COL_NAME, name, EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, TRUE, EMPATHY_CONTACT_LIST_STORE_COL_IS_ACTIVE, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, FALSE, + EMPATHY_CONTACT_LIST_STORE_COL_IS_FAKE_GROUP, is_fake_group, -1); + g_hash_table_insert (priv->empathy_group_cache, + g_strdup (name), gtk_tree_iter_copy (&iter_group)); + if (iter_group_to_set) { *iter_group_to_set = iter_group; } - gtk_tree_store_append (GTK_TREE_STORE (store), - &iter_separator, - &iter_group); - gtk_tree_store_set (GTK_TREE_STORE (store), &iter_separator, + gtk_tree_store_insert_with_values (GTK_TREE_STORE (store), &iter_separator, &iter_group, 0, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, TRUE, -1); @@ -1290,10 +1456,10 @@ contact_list_store_get_group (EmpathyContactListStore *store, } if (iter_group_to_set) { - *iter_group_to_set = fg.iter; + *iter_group_to_set = *iter; } - iter_separator = fg.iter; + iter_separator = *iter; if (gtk_tree_model_iter_next (model, &iter_separator)) { gboolean is_separator; @@ -1309,45 +1475,107 @@ contact_list_store_get_group (EmpathyContactListStore *store, } } +static gint +compare_separator_and_groups (gboolean is_separator_a, + gboolean is_separator_b, + const gchar *name_a, + const gchar *name_b, + EmpathyContact *contact_a, + EmpathyContact *contact_b, + gboolean fake_group_a, + gboolean fake_group_b) +{ + if (is_separator_a || is_separator_b) { + /* We have at least one separator */ + if (is_separator_a) { + return -1; + } else if (is_separator_b) { + return 1; + } + } + + /* One group and one contact */ + if (!contact_a && contact_b) { + return 1; + } else if (contact_a && !contact_b) { + return -1; + } else if (!contact_a && !contact_b) { + return g_utf8_collate (name_a, name_b); + } + + /* Two contacts, ordering depends of the sorting policy */ + return 0; +} + +static gint +contact_list_store_contact_sort (EmpathyContact *contact_a, + EmpathyContact *contact_b) +{ + TpAccount *account_a, *account_b; + gint ret_val; + + g_return_val_if_fail (contact_a != NULL || contact_b != NULL, 0); + + /* alias */ + ret_val = g_utf8_collate (empathy_contact_get_alias (contact_a), + empathy_contact_get_alias (contact_b)); + + if (ret_val != 0) + goto out; + + /* identifier */ + ret_val = g_utf8_collate (empathy_contact_get_id (contact_a), + empathy_contact_get_id (contact_b)); + + if (ret_val != 0) + goto out; + + account_a = empathy_contact_get_account (contact_a); + account_b = empathy_contact_get_account (contact_b); + + /* protocol */ + ret_val = strcmp (tp_account_get_protocol (account_a), + tp_account_get_protocol (account_b)); + + if (ret_val != 0) + goto out; + + /* account ID */ + ret_val = strcmp (tp_proxy_get_object_path (account_a), + tp_proxy_get_object_path (account_b)); + +out: + return ret_val; +} + static gint contact_list_store_state_sort_func (GtkTreeModel *model, GtkTreeIter *iter_a, GtkTreeIter *iter_b, gpointer user_data) { - gint ret_val = 0; + gint ret_val; gchar *name_a, *name_b; gboolean is_separator_a, is_separator_b; EmpathyContact *contact_a, *contact_b; + gboolean fake_group_a, fake_group_b; gtk_tree_model_get (model, iter_a, EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name_a, EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact_a, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, &is_separator_a, + EMPATHY_CONTACT_LIST_STORE_COL_IS_FAKE_GROUP, &fake_group_a, -1); gtk_tree_model_get (model, iter_b, EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name_b, EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact_b, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, &is_separator_b, + EMPATHY_CONTACT_LIST_STORE_COL_IS_FAKE_GROUP, &fake_group_b, -1); - /* Separator or group? */ - if (is_separator_a || is_separator_b) { - if (is_separator_a) { - ret_val = -1; - } else if (is_separator_b) { - ret_val = 1; - } - } else if (!contact_a && contact_b) { - ret_val = 1; - } else if (contact_a && !contact_b) { - ret_val = -1; - } else if (!contact_a && !contact_b) { - /* Handle groups */ - ret_val = g_utf8_collate (name_a, name_b); - } - - if (ret_val) { + if (contact_a == NULL || contact_b == NULL) { + ret_val = compare_separator_and_groups (is_separator_a, is_separator_b, + name_a, name_b, contact_a, contact_b, fake_group_a, fake_group_b); goto free_and_out; } @@ -1359,8 +1587,8 @@ contact_list_store_state_sort_func (GtkTreeModel *model, empathy_contact_get_presence (EMPATHY_CONTACT (contact_b))); if (ret_val == 0) { - /* Fallback: compare by name */ - ret_val = g_utf8_collate (name_a, name_b); + /* Fallback: compare by name et al. */ + ret_val = contact_list_store_contact_sort (contact_a, contact_b); } free_and_out: @@ -1386,38 +1614,28 @@ contact_list_store_name_sort_func (GtkTreeModel *model, { gchar *name_a, *name_b; EmpathyContact *contact_a, *contact_b; - gboolean is_separator_a, is_separator_b; + gboolean is_separator_a = FALSE, is_separator_b = FALSE; gint ret_val; + gboolean fake_group_a, fake_group_b; gtk_tree_model_get (model, iter_a, EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name_a, EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact_a, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, &is_separator_a, + EMPATHY_CONTACT_LIST_STORE_COL_IS_FAKE_GROUP, &fake_group_a, -1); gtk_tree_model_get (model, iter_b, EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name_b, EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact_b, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, &is_separator_b, + EMPATHY_CONTACT_LIST_STORE_COL_IS_FAKE_GROUP, &fake_group_b, -1); - /* If contact is NULL it means it's a group. */ - - if (is_separator_a || is_separator_b) { - if (is_separator_a) { - ret_val = -1; - } else if (is_separator_b) { - ret_val = 1; - } - } else if (!contact_a && contact_b) { - ret_val = 1; - } else if (contact_a && !contact_b) { - ret_val = -1; - } else { - ret_val = g_utf8_collate (name_a, name_b); - } - - g_free (name_a); - g_free (name_b); + if (contact_a == NULL || contact_b == NULL) + ret_val = compare_separator_and_groups (is_separator_a, is_separator_b, + name_a, name_b, contact_a, contact_b, fake_group_a, fake_group_b); + else + ret_val = contact_list_store_contact_sort (contact_a, contact_b); if (contact_a) { g_object_unref (contact_a); @@ -1430,55 +1648,28 @@ contact_list_store_name_sort_func (GtkTreeModel *model, return ret_val; } -static gboolean -contact_list_store_find_contact_foreach (GtkTreeModel *model, - GtkTreePath *path, - GtkTreeIter *iter, - FindContact *fc) -{ - EmpathyContact *contact; - - gtk_tree_model_get (model, iter, - EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact, - -1); - - if (contact == fc->contact) { - fc->found = TRUE; - fc->iters = g_list_append (fc->iters, gtk_tree_iter_copy (iter)); - } - - if (contact) { - g_object_unref (contact); - } - - return FALSE; -} - static GList * contact_list_store_find_contact (EmpathyContactListStore *store, EmpathyContact *contact) { - EmpathyContactListStorePriv *priv; - GtkTreeModel *model; - GList *l = NULL; - FindContact fc; - - priv = GET_PRIV (store); + EmpathyContactListStorePriv *priv = GET_PRIV (store); + GQueue *row_refs_queue; + GList *i; + GList *iters_list = NULL; - memset (&fc, 0, sizeof (fc)); + row_refs_queue = g_hash_table_lookup (priv->empathy_contact_cache, contact); + if (!row_refs_queue) + return NULL; - fc.contact = contact; + for (i = g_queue_peek_head_link (row_refs_queue) ; i != NULL ; + i = i->next) { + GtkTreeIter *iter = i->data; - model = GTK_TREE_MODEL (store); - gtk_tree_model_foreach (model, - (GtkTreeModelForeachFunc) contact_list_store_find_contact_foreach, - &fc); - - if (fc.found) { - l = fc.iters; + iters_list = g_list_prepend + (iters_list, gtk_tree_iter_copy (iter)); } - return l; + return iters_list; } static gboolean @@ -1488,7 +1679,9 @@ contact_list_store_update_list_mode_foreach (GtkTreeModel *model, EmpathyContactListStore *store) { EmpathyContactListStorePriv *priv; - gboolean show_avatar = FALSE; + gboolean show_avatar = FALSE; + EmpathyContact *contact; + GdkPixbuf *pixbuf_status; priv = GET_PRIV (store); @@ -1496,11 +1689,91 @@ contact_list_store_update_list_mode_foreach (GtkTreeModel *model, show_avatar = TRUE; } + gtk_tree_model_get (model, iter, + EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact, + -1); + + if (contact == NULL){ + return FALSE; + } + /* get icon from hash_table */ + pixbuf_status = contact_list_store_get_contact_status_icon (store, contact); + gtk_tree_store_set (GTK_TREE_STORE (store), iter, + EMPATHY_CONTACT_LIST_STORE_COL_ICON_STATUS, pixbuf_status, EMPATHY_CONTACT_LIST_STORE_COL_PIXBUF_AVATAR_VISIBLE, show_avatar, - EMPATHY_CONTACT_LIST_STORE_COL_STATUS_VISIBLE, !priv->is_compact, + EMPATHY_CONTACT_LIST_STORE_COL_COMPACT, priv->is_compact, -1); return FALSE; } +static GdkPixbuf * +contact_list_store_get_contact_status_icon_with_icon_name ( + EmpathyContactListStore *store, + EmpathyContact *contact, + const gchar *status_icon_name) +{ + GdkPixbuf *pixbuf_status = NULL; + EmpathyContactListStorePriv *priv; + const gchar *protocol_name = NULL; + gchar *icon_name = NULL; + + priv = GET_PRIV (store); + + 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_free (icon_name); + return pixbuf_status; +} + +GdkPixbuf * +contact_list_store_get_contact_status_icon (EmpathyContactListStore *store, + EmpathyContact *contact) +{ + GdkPixbuf *pixbuf_status = NULL; + EmpathyContactListStorePriv *priv; + const gchar *status_icon_name = NULL; + gboolean composing = FALSE; + + priv = GET_PRIV (store); + + if (EMPATHY_IS_TP_CHAT (priv->list)) { + if (empathy_tp_chat_get_chat_state (EMPATHY_TP_CHAT (priv->list), + contact) == + TP_CHANNEL_CHAT_STATE_COMPOSING) + composing = TRUE; + } + + if (composing) { + status_icon_name = EMPATHY_IMAGE_TYPING; + } else { + status_icon_name = empathy_icon_name_for_contact (contact); + } + + if (status_icon_name == NULL) + return NULL; + + pixbuf_status = contact_list_store_get_contact_status_icon_with_icon_name ( + store, + contact, + status_icon_name); + + return pixbuf_status; +}