X-Git-Url: https://git.0d.be/?p=empathy.git;a=blobdiff_plain;f=libempathy-gtk%2Fempathy-contact-list-store.c;h=6b35b082440ab1835f2f35578828a1eb4bec67b7;hp=8638ce12ef77653364715d649bb26f828d852a98;hb=940d0e9778828657a6ffbcadd35a8a84d706ac70;hpb=0ab84cc3ffe6129ae40ad436eb62fccbd52b00ad diff --git a/libempathy-gtk/empathy-contact-list-store.c b/libempathy-gtk/empathy-contact-list-store.c index 8638ce12..6b35b082 100644 --- a/libempathy-gtk/empathy-contact-list-store.c +++ b/libempathy-gtk/empathy-contact-list-store.c @@ -1,7 +1,7 @@ /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ /* * Copyright (C) 2005-2007 Imendio AB - * Copyright (C) 2007 Collabora Ltd. + * Copyright (C) 2007-2008 Collabora Ltd. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -15,8 +15,8 @@ * * You should have received a copy of the GNU General Public * License along with this program; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, + * Boston, MA 02110-1301 USA * * Authors: Mikael Hallendal * Martyn Russell @@ -28,16 +28,21 @@ #include #include +#include #include -#include +#include + +#include +#include +#include #include "empathy-contact-list-store.h" -#include "empathy-contact-groups.h" #include "empathy-ui-utils.h" #include "empathy-gtk-enum-types.h" -#define DEBUG_DOMAIN "ContactListStore" +#define DEBUG_FLAG EMPATHY_DEBUG_CONTACT +#include /* Active users are those which have recently changed state * (e.g. online, offline or from normal to a busy state). @@ -49,20 +54,21 @@ /* Time in seconds after connecting which we wait before active users are enabled */ #define ACTIVE_USER_WAIT_TO_ENABLE_TIME 5 -#define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), EMPATHY_TYPE_CONTACT_LIST_STORE, EmpathyContactListStorePriv)) - -struct _EmpathyContactListStorePriv { +#define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyContactListStore) +typedef struct { EmpathyContactList *list; gboolean show_offline; gboolean show_avatars; + gboolean show_groups; gboolean is_compact; + gboolean show_protocols; gboolean show_active; EmpathyContactListStoreSort sort_criterium; guint inhibit_active; - - EmpathyContactGroupsFunc get_contact_groups; - gpointer get_contact_groups_data; -}; + guint setup_idle_id; + gboolean dispose_has_run; + GHashTable *status_icons; +} EmpathyContactListStorePriv; typedef struct { GtkTreeIter iter; @@ -82,9 +88,7 @@ typedef struct { gboolean remove; } ShowActiveData; -static void empathy_contact_list_store_class_init (EmpathyContactListStoreClass *klass); -static void empathy_contact_list_store_init (EmpathyContactListStore *list); -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, @@ -93,10 +97,6 @@ static void contact_list_store_set_property (GObject guint param_id, const GValue *value, GParamSpec *pspec); -static gboolean contact_list_store_finalize_foreach (GtkTreeModel *model, - GtkTreePath *path, - GtkTreeIter *iter, - gpointer user_data); static void contact_list_store_setup (EmpathyContactListStore *store); static gboolean contact_list_store_inibit_active_cb (EmpathyContactListStore *store); static void contact_list_store_members_changed_cb (EmpathyContactList *list_iface, @@ -106,6 +106,16 @@ static void contact_list_store_members_changed_cb (EmpathyCon gchar *message, gboolean is_member, EmpathyContactListStore *store); +static void contact_list_store_favourites_changed_cb (EmpathyContactList *list_iface, + EmpathyContact *contact, + gboolean is_favourite, + 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, @@ -137,7 +147,8 @@ static void contact_list_store_get_group (EmpathyCon 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, @@ -159,23 +170,88 @@ static gboolean contact_list_store_update_list_mode_foreach (GtkTreeMod enum { PROP_0, + PROP_CONTACT_LIST, PROP_SHOW_OFFLINE, PROP_SHOW_AVATARS, + PROP_SHOW_PROTOCOLS, + PROP_SHOW_GROUPS, PROP_IS_COMPACT, PROP_SORT_CRITERIUM }; G_DEFINE_TYPE (EmpathyContactListStore, empathy_contact_list_store, GTK_TYPE_TREE_STORE); +static gboolean +contact_list_store_iface_setup (gpointer user_data) +{ + EmpathyContactListStore *store = user_data; + EmpathyContactListStorePriv *priv = GET_PRIV (store); + 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), + store); + g_signal_connect (priv->list, + "favourites-changed", + G_CALLBACK (contact_list_store_favourites_changed_cb), + store); + g_signal_connect (priv->list, + "groups-changed", + G_CALLBACK (contact_list_store_groups_changed_cb), + store); + + /* Add contacts already created. */ + 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); + + priv->setup_idle_id = 0; + return FALSE; +} + + +static void +contact_list_store_set_contact_list (EmpathyContactListStore *store, + EmpathyContactList *list_iface) +{ + EmpathyContactListStorePriv *priv = GET_PRIV (store); + + priv->list = g_object_ref (list_iface); + + /* Let a chance to have all properties set before populating */ + priv->setup_idle_id = g_idle_add (contact_list_store_iface_setup, store); +} + static void 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; + g_object_class_install_property (object_class, + PROP_CONTACT_LIST, + g_param_spec_object ("contact-list", + "The contact list iface", + "The contact list iface", + EMPATHY_TYPE_CONTACT_LIST, + G_PARAM_CONSTRUCT_ONLY | + G_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_SHOW_OFFLINE, g_param_spec_boolean ("show-offline", @@ -192,6 +268,22 @@ 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", + "Show Groups", + "Whether contact list should display " + "contact groups", + TRUE, + G_PARAM_READWRITE)); g_object_class_install_property (object_class, PROP_IS_COMPACT, g_param_spec_boolean ("is-compact", @@ -215,42 +307,64 @@ empathy_contact_list_store_class_init (EmpathyContactListStoreClass *klass) static void empathy_contact_list_store_init (EmpathyContactListStore *store) { - EmpathyContactListStorePriv *priv; - - priv = GET_PRIV (store); + EmpathyContactListStorePriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (store, + EMPATHY_TYPE_CONTACT_LIST_STORE, EmpathyContactListStorePriv); + 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); + contact_list_store_setup (store); } static void -contact_list_store_finalize (GObject *object) +contact_list_store_dispose (GObject *object) { - EmpathyContactListStorePriv *priv; + EmpathyContactListStorePriv *priv = GET_PRIV (object); + GList *contacts, *l; - priv = GET_PRIV (object); - - gtk_tree_model_foreach (GTK_TREE_MODEL (object), - (GtkTreeModelForeachFunc) contact_list_store_finalize_foreach, - object); + if (priv->dispose_has_run) + return; + priv->dispose_has_run = TRUE; - if (priv->list) { - g_signal_handlers_disconnect_by_func (priv->list, - G_CALLBACK (contact_list_store_members_changed_cb), - object); - g_signal_handlers_disconnect_by_func (priv->list, - G_CALLBACK (contact_list_store_groups_changed_cb), + contacts = empathy_contact_list_get_members (priv->list); + for (l = contacts; l; l = l->next) { + g_signal_handlers_disconnect_by_func (l->data, + G_CALLBACK (contact_list_store_contact_updated_cb), object); - g_object_unref (priv->list); + + g_object_unref (l->data); } + 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); + g_signal_handlers_disconnect_by_func (priv->list, + G_CALLBACK (contact_list_store_favourites_changed_cb), + object); + g_signal_handlers_disconnect_by_func (priv->list, + G_CALLBACK (contact_list_store_groups_changed_cb), + object); + g_object_unref (priv->list); if (priv->inhibit_active) { g_source_remove (priv->inhibit_active); } - G_OBJECT_CLASS (empathy_contact_list_store_parent_class)->finalize (object); + if (priv->setup_idle_id != 0) { + g_source_remove (priv->setup_idle_id); + } + + g_hash_table_destroy (priv->status_icons); + G_OBJECT_CLASS (empathy_contact_list_store_parent_class)->dispose (object); } static void @@ -264,12 +378,21 @@ contact_list_store_get_property (GObject *object, priv = GET_PRIV (object); switch (param_id) { + case PROP_CONTACT_LIST: + g_value_set_object (value, priv->list); + break; case PROP_SHOW_OFFLINE: g_value_set_boolean (value, priv->show_offline); break; 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; case PROP_IS_COMPACT: g_value_set_boolean (value, priv->is_compact); break; @@ -293,6 +416,10 @@ contact_list_store_set_property (GObject *object, priv = GET_PRIV (object); switch (param_id) { + case PROP_CONTACT_LIST: + contact_list_store_set_contact_list (EMPATHY_CONTACT_LIST_STORE (object), + g_value_get_object (value)); + break; case PROP_SHOW_OFFLINE: empathy_contact_list_store_set_show_offline (EMPATHY_CONTACT_LIST_STORE (object), g_value_get_boolean (value)); @@ -301,6 +428,14 @@ 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)); + break; case PROP_IS_COMPACT: empathy_contact_list_store_set_is_compact (EMPATHY_CONTACT_LIST_STORE (object), g_value_get_boolean (value)); @@ -318,41 +453,11 @@ contact_list_store_set_property (GObject *object, EmpathyContactListStore * empathy_contact_list_store_new (EmpathyContactList *list_iface) { - EmpathyContactListStore *store; - EmpathyContactListStorePriv *priv; - GList *contacts, *l; - g_return_val_if_fail (EMPATHY_IS_CONTACT_LIST (list_iface), NULL); - store = g_object_new (EMPATHY_TYPE_CONTACT_LIST_STORE, NULL); - priv = GET_PRIV (store); - - contact_list_store_setup (store); - priv->list = g_object_ref (list_iface); - - /* Signal connection. */ - g_signal_connect (priv->list, - "members-changed", - G_CALLBACK (contact_list_store_members_changed_cb), - store); - g_signal_connect (priv->list, - "groups-changed", - G_CALLBACK (contact_list_store_groups_changed_cb), - store); - - /* Add contacts already created. */ - 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); - - return store; + return g_object_new (EMPATHY_TYPE_CONTACT_LIST_STORE, + "contact-list", list_iface, + NULL); } EmpathyContactList * @@ -407,6 +512,8 @@ empathy_contact_list_store_set_show_offline (EmpathyContactListStore *store, /* Restore to original setting. */ priv->show_active = show_active; + + g_object_notify (G_OBJECT (store), "show-offline"); } gboolean @@ -440,6 +547,90 @@ empathy_contact_list_store_set_show_avatars (EmpathyContactListStore *store, (GtkTreeModelForeachFunc) contact_list_store_update_list_mode_foreach, 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) +{ + EmpathyContactListStorePriv *priv; + + g_return_val_if_fail (EMPATHY_IS_CONTACT_LIST_STORE (store), TRUE); + + priv = GET_PRIV (store); + + return priv->show_groups; +} + +void +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)); + + priv = GET_PRIV (store); + + if (priv->show_groups == show_groups) { + return; + } + + 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); + } + g_list_free (contacts); + + g_object_notify (G_OBJECT (store), "show-groups"); } gboolean @@ -473,6 +664,8 @@ empathy_contact_list_store_set_is_compact (EmpathyContactListStore *store, (GtkTreeModelForeachFunc) contact_list_store_update_list_mode_foreach, store); + + g_object_notify (G_OBJECT (store), "is-compact"); } EmpathyContactListStoreSort @@ -502,16 +695,18 @@ empathy_contact_list_store_set_sort_criterium (EmpathyContactListStore *stor switch (sort_criterium) { case EMPATHY_CONTACT_LIST_STORE_SORT_STATE: gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), - COL_STATUS, + EMPATHY_CONTACT_LIST_STORE_COL_STATUS, GTK_SORT_ASCENDING); break; - + case EMPATHY_CONTACT_LIST_STORE_SORT_NAME: gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), - COL_NAME, + EMPATHY_CONTACT_LIST_STORE_COL_NAME, GTK_SORT_ASCENDING); break; } + + g_object_notify (G_OBJECT (store), "sort-criterium"); } gboolean @@ -524,7 +719,7 @@ empathy_contact_list_store_row_separator_func (GtkTreeModel *model, g_return_val_if_fail (GTK_IS_TREE_MODEL (model), FALSE); gtk_tree_model_get (model, iter, - COL_IS_SEPARATOR, &is_separator, + EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, &is_separator, -1); return is_separator; @@ -533,11 +728,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); @@ -550,8 +747,8 @@ empathy_contact_list_store_get_parent_group (GtkTreeModel *model, } gtk_tree_model_get (model, &iter, - COL_IS_GROUP, &is_group, - COL_NAME, &name, + EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group, + EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name, -1); if (!is_group) { @@ -565,8 +762,9 @@ empathy_contact_list_store_get_parent_group (GtkTreeModel *model, iter = parent_iter; gtk_tree_model_get (model, &iter, - COL_IS_GROUP, &is_group, - COL_NAME, &name, + 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); @@ -578,6 +776,9 @@ empathy_contact_list_store_get_parent_group (GtkTreeModel *model, *path_is_group = TRUE; } + if (is_fake_group != NULL) + *is_fake_group = fake; + return name; } @@ -598,7 +799,9 @@ empathy_contact_list_store_search_equal_func (GtkTreeModel *model, return TRUE; } - gtk_tree_model_get (model, iter, COL_NAME, &name, -1); + gtk_tree_model_get (model, iter, + EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name, + -1); if (!name) { return TRUE; @@ -607,7 +810,7 @@ empathy_contact_list_store_search_equal_func (GtkTreeModel *model, name_folded = g_utf8_casefold (name, -1); key_folded = g_utf8_casefold (key, -1); - if (name_folded && key_folded && + if (name_folded && key_folded && strstr (name_folded, key_folded)) { ret = FALSE; } else { @@ -621,56 +824,42 @@ empathy_contact_list_store_search_equal_func (GtkTreeModel *model, return ret; } -static gboolean -contact_list_store_finalize_foreach (GtkTreeModel *model, - GtkTreePath *path, - GtkTreeIter *iter, - gpointer user_data) -{ - EmpathyContactListStore *store = user_data; - EmpathyContact *contact = NULL; - - gtk_tree_model_get (GTK_TREE_MODEL (store), iter, - COL_CONTACT, &contact, - -1); - - if (contact) { - g_signal_handlers_disconnect_by_func (contact, - G_CALLBACK (contact_list_store_contact_updated_cb), - store); - } - - return FALSE; -} - 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 VoIP */ - + 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); - gtk_tree_store_set_column_types (GTK_TREE_STORE (store), COL_COUNT, types); + gtk_tree_store_set_column_types (GTK_TREE_STORE (store), + EMPATHY_CONTACT_LIST_STORE_COL_COUNT, + types); /* Set up sorting */ gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store), - COL_NAME, + EMPATHY_CONTACT_LIST_STORE_COL_NAME, contact_list_store_name_sort_func, store, NULL); gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store), - COL_STATUS, + EMPATHY_CONTACT_LIST_STORE_COL_STATUS, contact_list_store_state_sort_func, store, NULL); @@ -691,6 +880,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, @@ -704,36 +925,62 @@ contact_list_store_members_changed_cb (EmpathyContactList *list_iface, priv = GET_PRIV (store); - empathy_debug (DEBUG_DOMAIN, - "Contact %s (%d) %s", - empathy_contact_get_id (contact), - empathy_contact_get_handle (contact), - is_member ? "added" : "removed"); + 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::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_favourites_changed_cb (EmpathyContactList *list_iface, + EmpathyContact *contact, + gboolean is_favourite, + EmpathyContactListStore *store) +{ + EmpathyContactListStorePriv *priv; + + priv = GET_PRIV (store); + + DEBUG ("Contact %s (%d) is %s a favourite", + empathy_contact_get_id (contact), + empathy_contact_get_handle (contact), + is_favourite ? "now" : "no longer"); + + contact_list_store_remove_contact (store, contact); + contact_list_store_add_contact (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) +{ + EmpathyContactListStorePriv *priv; + + priv = GET_PRIV (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, @@ -746,9 +993,9 @@ contact_list_store_groups_changed_cb (EmpathyContactList *list_iface, priv = GET_PRIV (store); - empathy_debug (DEBUG_DOMAIN, "Updating groups for contact %s (%d)", - empathy_contact_get_id (contact), - empathy_contact_get_handle (contact)); + DEBUG ("Updating groups for contact %s (%d)", + empathy_contact_get_id (contact), + empathy_contact_get_handle (contact)); /* We do this to make sure the groups are correct, if not, we * would have to check the groups already set up for each @@ -761,55 +1008,132 @@ contact_list_store_groups_changed_cb (EmpathyContactList *list_iface, priv->show_active = show_active; } +static void +add_contact_to_store (GtkTreeStore *store, + GtkTreeIter *iter, + EmpathyContact *contact, + EmpathyContactListFlags flags) +{ + gtk_tree_store_set (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, + EMPATHY_CONTACT_LIST_STORE_COL_FLAGS, flags, + -1); +} + static void contact_list_store_add_contact (EmpathyContactListStore *store, EmpathyContact *contact) { EmpathyContactListStorePriv *priv; GtkTreeIter iter; - GList *groups, *l; + GList *groups = NULL, *l; + TpConnection *connection; + EmpathyContactListFlags flags = 0; + char *protocol_name; priv = GET_PRIV (store); - - if (!priv->show_offline && !empathy_contact_is_online (contact)) { + + if (EMP_STR_EMPTY (empathy_contact_get_name (contact)) || + (!priv->show_offline && !empathy_contact_is_online (contact))) { return; } - groups = empathy_contact_list_get_groups (priv->list, contact); + if (priv->show_groups) { + groups = empathy_contact_list_get_groups (priv->list, contact); + } + + 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 no groups just add it at the top level. */ if (!groups) { +#if HAVE_FAVOURITE_CONTACTS + GtkTreeIter iter_group; + + if (!tp_strdiff (protocol_name, "local-xmpp")) { + /* these are People Nearby */ + contact_list_store_get_group (store, + EMPATHY_CONTACT_LIST_STORE_PEOPLE_NEARBY, + &iter_group, NULL, NULL, TRUE); + } else { + contact_list_store_get_group (store, + EMPATHY_CONTACT_LIST_STORE_UNGROUPED, + &iter_group, NULL, NULL, TRUE); + } + + gtk_tree_store_insert_after (GTK_TREE_STORE (store), &iter, + &iter_group, NULL); +#else + /* FIXME: remove this in 2.31.x */ + /* If no groups just add it at the top level. */ + GtkTreeModel *model = GTK_TREE_MODEL (store); + + if (gtk_tree_model_get_iter_first (model, &iter)) do { + EmpathyContact *c; + + gtk_tree_model_get (model, &iter, + EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &c, + -1); + + if (c == contact) { + g_object_unref (c); + return; + } + if (c != NULL) + g_object_unref (c); + } while (gtk_tree_model_iter_next (model, &iter)); + gtk_tree_store_append (GTK_TREE_STORE (store), &iter, NULL); - gtk_tree_store_set (GTK_TREE_STORE (store), &iter, - COL_NAME, empathy_contact_get_name (contact), - COL_CONTACT, contact, - COL_IS_GROUP, FALSE, - COL_IS_SEPARATOR, FALSE, - COL_CAN_VOIP, empathy_contact_can_voip (contact), - -1); +#endif + + add_contact_to_store (GTK_TREE_STORE (store), &iter, 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, - COL_NAME, empathy_contact_get_name (contact), - COL_CONTACT, contact, - COL_IS_GROUP, FALSE, - COL_IS_SEPARATOR, FALSE, - COL_CAN_VOIP, empathy_contact_can_voip (contact), - -1); + + add_contact_to_store (GTK_TREE_STORE (store), &iter, contact, flags); g_free (l->data); } g_list_free (groups); - contact_list_store_contact_update (store, contact); +#ifdef HAVE_FAVOURITE_CONTACTS + if (empathy_contact_list_is_favourite (priv->list, contact)) { + /* Add contact to the fake 'Favorites' group */ + GtkTreeIter iter_group; + contact_list_store_get_group (store, EMPATHY_CONTACT_LIST_STORE_FAVORITE, + &iter_group, NULL, NULL, TRUE); + + gtk_tree_store_insert_after (GTK_TREE_STORE (store), &iter, + &iter_group, NULL); + + add_contact_to_store (GTK_TREE_STORE (store), &iter, contact, flags); + } +#endif + + contact_list_store_contact_update (store, contact); } static void @@ -826,7 +1150,7 @@ contact_list_store_remove_contact (EmpathyContactListStore *store, if (!iters) { return; } - + /* Clean up model */ model = GTK_TREE_MODEL (store); @@ -835,7 +1159,7 @@ contact_list_store_remove_contact (EmpathyContactListStore *store, /* NOTE: it is only <= 2 here because we have * separators after the group name, otherwise it - * should be 1. + * should be 1. */ if (gtk_tree_model_iter_parent (model, &parent, l->data) && gtk_tree_model_iter_n_children (model, &parent) <= 2) { @@ -865,7 +1189,9 @@ contact_list_store_contact_update (EmpathyContactListStore *store, gboolean do_remove = FALSE; gboolean do_set_active = FALSE; gboolean do_set_refresh = FALSE; + gboolean show_avatar = FALSE; GdkPixbuf *pixbuf_avatar; + GdkPixbuf *pixbuf_status; priv = GET_PRIV (store); @@ -889,18 +1215,16 @@ contact_list_store_contact_update (EmpathyContactListStore *store, if (!in_list && !should_be_in_list) { /* Nothing to do. */ - empathy_debug (DEBUG_DOMAIN, - "Contact:'%s' in list:NO, should be:NO", - empathy_contact_get_name (contact)); + DEBUG ("Contact:'%s' in list:NO, should be:NO", + empathy_contact_get_name (contact)); g_list_foreach (iters, (GFunc) gtk_tree_iter_free, NULL); g_list_free (iters); return; } else if (in_list && !should_be_in_list) { - empathy_debug (DEBUG_DOMAIN, - "Contact:'%s' in list:YES, should be:NO", - empathy_contact_get_name (contact)); + DEBUG ("Contact:'%s' in list:YES, should be:NO", + empathy_contact_get_name (contact)); if (priv->show_active) { do_remove = TRUE; @@ -908,33 +1232,31 @@ contact_list_store_contact_update (EmpathyContactListStore *store, do_set_refresh = TRUE; set_model = TRUE; - empathy_debug (DEBUG_DOMAIN, "Remove item (after timeout)"); + DEBUG ("Remove item (after timeout)"); } else { - empathy_debug (DEBUG_DOMAIN, "Remove item (now)!"); + DEBUG ("Remove item (now)!"); contact_list_store_remove_contact (store, contact); } } else if (!in_list && should_be_in_list) { - empathy_debug (DEBUG_DOMAIN, - "Contact:'%s' in list:NO, should be:YES", - empathy_contact_get_name (contact)); + DEBUG ("Contact:'%s' in list:NO, should be:YES", + empathy_contact_get_name (contact)); contact_list_store_add_contact (store, contact); if (priv->show_active) { do_set_active = TRUE; - empathy_debug (DEBUG_DOMAIN, "Set active (contact added)"); + DEBUG ("Set active (contact added)"); } } else { - empathy_debug (DEBUG_DOMAIN, - "Contact:'%s' in list:YES, should be:YES", - empathy_contact_get_name (contact)); + DEBUG ("Contact:'%s' in list:YES, should be:YES", + empathy_contact_get_name (contact)); /* Get online state before. */ if (iters && g_list_length (iters) > 0) { gtk_tree_model_get (model, iters->data, - COL_IS_ONLINE, &was_online, + EMPATHY_CONTACT_LIST_STORE_COL_IS_ONLINE, &was_online, -1); } @@ -944,34 +1266,46 @@ contact_list_store_contact_update (EmpathyContactListStore *store, do_set_active = TRUE; do_set_refresh = TRUE; - empathy_debug (DEBUG_DOMAIN, "Set active (contact updated %s)", - was_online ? "online -> offline" : - "offline -> online"); + DEBUG ("Set active (contact updated %s)", + was_online ? "online -> offline" : + "offline -> online"); } else { /* Was TRUE for presence updates. */ /* do_set_active = FALSE; */ do_set_refresh = TRUE; - empathy_debug (DEBUG_DOMAIN, "Set active (contact updated)"); + DEBUG ("Set active (contact updated)"); } } set_model = TRUE; } + if (priv->show_avatars && !priv->is_compact) { + 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, - COL_ICON_STATUS, empathy_icon_name_for_contact (contact), - COL_PIXBUF_AVATAR, pixbuf_avatar, - COL_PIXBUF_AVATAR_VISIBLE, priv->show_avatars, - COL_NAME, empathy_contact_get_name (contact), - COL_STATUS, empathy_contact_get_status (contact), - COL_STATUS_VISIBLE, !priv->is_compact, - COL_IS_GROUP, FALSE, - COL_IS_ONLINE, now_online, - COL_IS_SEPARATOR, FALSE, - COL_CAN_VOIP, empathy_contact_can_voip (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_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, + 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); } @@ -1004,9 +1338,8 @@ contact_list_store_contact_updated_cb (EmpathyContact *contact, GParamSpec *param, EmpathyContactListStore *store) { - empathy_debug (DEBUG_DOMAIN, - "Contact:'%s' updated, checking roster is in sync...", - empathy_contact_get_name (contact)); + DEBUG ("Contact:'%s' updated, checking roster is in sync...", + empathy_contact_get_name (contact)); contact_list_store_contact_update (store, contact); } @@ -1029,10 +1362,10 @@ contact_list_store_contact_set_active (EmpathyContactListStore *store, GtkTreePath *path; gtk_tree_store_set (GTK_TREE_STORE (store), l->data, - COL_IS_ACTIVE, active, + EMPATHY_CONTACT_LIST_STORE_COL_IS_ACTIVE, active, -1); - empathy_debug (DEBUG_DOMAIN, "Set item %s", active ? "active" : "inactive"); + DEBUG ("Set item %s", active ? "active" : "inactive"); if (set_changed) { path = gtk_tree_model_get_path (model, l->data); @@ -1049,20 +1382,19 @@ contact_list_store_contact_set_active (EmpathyContactListStore *store, static ShowActiveData * contact_list_store_contact_active_new (EmpathyContactListStore *store, EmpathyContact *contact, - gboolean remove) + gboolean remove_) { ShowActiveData *data; - empathy_debug (DEBUG_DOMAIN, - "Contact:'%s' now active, and %s be removed", - empathy_contact_get_name (contact), - remove ? "WILL" : "WILL NOT"); - + DEBUG ("Contact:'%s' now active, and %s be removed", + empathy_contact_get_name (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; + data->remove = remove_; return data; } @@ -1086,15 +1418,13 @@ contact_list_store_contact_active_cb (ShowActiveData *data) if (data->remove && !priv->show_offline && !empathy_contact_is_online (data->contact)) { - empathy_debug (DEBUG_DOMAIN, - "Contact:'%s' active timeout, removing item", - empathy_contact_get_name (data->contact)); + DEBUG ("Contact:'%s' active timeout, removing item", + empathy_contact_get_name (data->contact)); contact_list_store_remove_contact (data->store, data->contact); } - empathy_debug (DEBUG_DOMAIN, - "Contact:'%s' no longer active", - empathy_contact_get_name (data->contact)); + DEBUG ("Contact:'%s' no longer active", + empathy_contact_get_name (data->contact)); contact_list_store_contact_set_active (data->store, data->contact, @@ -1121,11 +1451,11 @@ contact_list_store_get_group_foreach (GtkTreeModel *model, } gtk_tree_model_get (model, iter, - COL_NAME, &str, - COL_IS_GROUP, &is_group, + EMPATHY_CONTACT_LIST_STORE_COL_NAME, &str, + EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group, -1); - if (is_group && strcmp (str, fg->name) == 0) { + if (is_group && !tp_strdiff (str, fg->name)) { fg->found = TRUE; fg->iter = *iter; } @@ -1140,7 +1470,8 @@ 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; GtkTreeModel *model; @@ -1166,11 +1497,12 @@ contact_list_store_get_group (EmpathyContactListStore *store, gtk_tree_store_append (GTK_TREE_STORE (store), &iter_group, NULL); gtk_tree_store_set (GTK_TREE_STORE (store), &iter_group, - COL_ICON_STATUS, NULL, - COL_NAME, name, - COL_IS_GROUP, TRUE, - COL_IS_ACTIVE, FALSE, - COL_IS_SEPARATOR, FALSE, + 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); if (iter_group_to_set) { @@ -1178,10 +1510,10 @@ contact_list_store_get_group (EmpathyContactListStore *store, } gtk_tree_store_append (GTK_TREE_STORE (store), - &iter_separator, + &iter_separator, &iter_group); gtk_tree_store_set (GTK_TREE_STORE (store), &iter_separator, - COL_IS_SEPARATOR, TRUE, + EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, TRUE, -1); if (iter_separator_to_set) { @@ -1202,7 +1534,7 @@ contact_list_store_get_group (EmpathyContactListStore *store, gboolean is_separator; gtk_tree_model_get (model, &iter_separator, - COL_IS_SEPARATOR, &is_separator, + EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, &is_separator, -1); if (is_separator && iter_separator_to_set) { @@ -1212,75 +1544,133 @@ contact_list_store_get_group (EmpathyContactListStore *store, } } +static gint +get_position (const char **strv, + const char *str) +{ + int i; + + for (i = 0; strv[i] != NULL; i++) { + if (!tp_strdiff (strv[i], str)) + return i; + } + + return -1; +} + +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) +{ + /* these two lists are the sorted list of fake groups to include at the + * top and bottom of the roster */ + const char *top_groups[] = { + EMPATHY_CONTACT_LIST_STORE_FAVORITE, + NULL + }; + + const char *bottom_groups[] = { + EMPATHY_CONTACT_LIST_STORE_UNGROUPED, + NULL + }; + + 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) { + gboolean a_in_top, b_in_top, a_in_bottom, b_in_bottom; + + a_in_top = fake_group_a && + tp_strv_contains (top_groups, name_a); + b_in_top = fake_group_b && + tp_strv_contains (top_groups, name_b); + a_in_bottom = fake_group_b && + tp_strv_contains (bottom_groups, name_a); + b_in_bottom = fake_group_b && + tp_strv_contains (bottom_groups, name_b); + + if (a_in_top && b_in_top) { + /* compare positions */ + return CLAMP (get_position (top_groups, name_a) - + get_position (top_groups, name_b), + -1, 1); + } else if (a_in_bottom && b_in_bottom) { + /* compare positions */ + return CLAMP (get_position (bottom_groups, name_a) - + get_position (bottom_groups, name_b), + -1, 1); + } else if (a_in_top || b_in_bottom) { + return -1; + } else if (b_in_top || a_in_bottom) { + return 1; + } else { + return g_utf8_collate (name_a, name_b); + } + } + + /* Two contacts, ordering depends of the sorting policy */ + return 0; +} + 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; - EmpathyPresence *presence_a, *presence_b; - McPresence state_a, state_b; + EmpathyContact *contact_a, *contact_b; + gboolean fake_group_a, fake_group_b; gtk_tree_model_get (model, iter_a, - COL_NAME, &name_a, - COL_CONTACT, &contact_a, - COL_IS_SEPARATOR, &is_separator_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, - COL_NAME, &name_b, - COL_CONTACT, &contact_b, - COL_IS_SEPARATOR, &is_separator_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); - } + 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); - if (ret_val) { + if (ret_val != 0) { goto free_and_out; } /* If we managed to get this far, we can start looking at * the presences. */ - presence_a = empathy_contact_get_presence (EMPATHY_CONTACT (contact_a)); - presence_b = empathy_contact_get_presence (EMPATHY_CONTACT (contact_b)); - - if (!presence_a && presence_b) { - ret_val = 1; - } else if (presence_a && !presence_b) { - ret_val = -1; - } else if (!presence_a && !presence_b) { - /* Both offline, sort by name */ - ret_val = g_utf8_collate (name_a, name_b); - } else { - state_a = empathy_presence_get_state (presence_a); - state_b = empathy_presence_get_state (presence_b); + ret_val = -tp_connection_presence_type_cmp_availability ( + empathy_contact_get_presence (EMPATHY_CONTACT (contact_a)), + empathy_contact_get_presence (EMPATHY_CONTACT (contact_b))); - if (state_a < state_b) { - ret_val = -1; - } else if (state_a > state_b) { - ret_val = 1; - } else { - /* Fallback: compare by name */ - ret_val = g_utf8_collate (name_a, name_b); - } + if (ret_val == 0) { + /* Fallback: compare by name */ + ret_val = g_utf8_collate (name_a, name_b); } free_and_out: @@ -1306,38 +1696,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, - COL_NAME, &name_a, - COL_CONTACT, &contact_a, - COL_IS_SEPARATOR, &is_separator_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, - COL_NAME, &name_b, - COL_CONTACT, &contact_b, - COL_IS_SEPARATOR, &is_separator_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. */ + 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); - 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 (ret_val == 0) ret_val = g_utf8_collate (name_a, name_b); - } - - g_free (name_a); - g_free (name_b); if (contact_a) { g_object_unref (contact_a); @@ -1359,18 +1739,17 @@ contact_list_store_find_contact_foreach (GtkTreeModel *model, EmpathyContact *contact; gtk_tree_model_get (model, iter, - COL_CONTACT, &contact, + EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact, -1); - if (!contact) { - return FALSE; - } - - if (empathy_contact_equal (contact, fc->contact)) { + if (contact == fc->contact) { fc->found = TRUE; fc->iters = g_list_append (fc->iters, gtk_tree_iter_copy (iter)); } - g_object_unref (contact); + + if (contact) { + g_object_unref (contact); + } return FALSE; } @@ -1409,7 +1788,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); @@ -1417,11 +1798,75 @@ 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, - COL_PIXBUF_AVATAR_VISIBLE, show_avatar, - COL_STATUS_VISIBLE, !priv->is_compact, + EMPATHY_CONTACT_LIST_STORE_COL_ICON_STATUS, pixbuf_status, + EMPATHY_CONTACT_LIST_STORE_COL_PIXBUF_AVATAR_VISIBLE, show_avatar, + 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; + const gchar *status_icon_name = NULL; + + 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; +}