#include <telepathy-glib/util.h>
#include <libempathy/empathy-utils.h>
+#include <libempathy/empathy-tp-chat.h>
#include <libempathy/empathy-enum-types.h>
#include <libempathy/empathy-contact-manager.h>
#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 <libempathy/empathy-debug.h>
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_dispose (GObject *object);
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,
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_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,
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)
{
"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);
+ 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) {
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)
{
(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);
}
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) {
+ 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_hash_table_destroy (priv->status_icons);
+ 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);
}
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),
gboolean show_groups)
{
EmpathyContactListStorePriv *priv;
- GList *contacts, *l;
g_return_if_fail (EMPATHY_IS_CONTACT_LIST_STORE (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");
}
EMPATHY_CONTACT_LIST_STORE_COL_NAME,
GTK_SORT_ASCENDING);
break;
+
+ default:
+ g_assert_not_reached ();
}
g_object_notify (G_OBJECT (store), "sort-criterium");
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);
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);
*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 (is_fake_group != NULL)
+ *is_fake_group = fake;
- if (!name) {
- return TRUE;
- }
-
- name_folded = g_utf8_casefold (name, -1);
- key_folded = g_utf8_casefold (key, -1);
-
- 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
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, /* Show status */
+ G_TYPE_BOOLEAN, /* Compact view */
EMPATHY_TYPE_CONTACT, /* Contact type */
G_TYPE_BOOLEAN, /* Is group */
G_TYPE_BOOLEAN, /* Is active */
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 favourite */
G_TYPE_BOOLEAN, /* Is a fake group */
};
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),
}
}
-static void
-contact_list_store_change_contact_favourite_status (EmpathyContactListStore *store,
- EmpathyContact *contact,
- gboolean is_favourite)
-{
- GList *iters, *l;
-
- iters = contact_list_store_find_contact (store, contact);
- for (l = iters; l; l = l->next) {
- gtk_tree_store_set (GTK_TREE_STORE (store), l->data,
- EMPATHY_CONTACT_LIST_STORE_COL_IS_FAVOURITE,
- is_favourite,
- -1);
- }
-
- g_list_foreach (iters, (GFunc) gtk_tree_iter_free, NULL);
- g_list_free (iters);
-}
-
-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_change_contact_favourite_status (store, contact,
- is_favourite);
-
- 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,
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),
static void
add_contact_to_store (GtkTreeStore *store,
GtkTreeIter *iter,
+ GtkTreeIter *parent,
EmpathyContact *contact,
EmpathyContactListFlags flags)
{
- gtk_tree_store_set (store, iter,
- EMPATHY_CONTACT_LIST_STORE_COL_NAME, empathy_contact_get_name (contact),
+ 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_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
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;
}
flags = empathy_contact_manager_get_flags_for_connection (
EMPATHY_CONTACT_MANAGER (priv->list), connection);
}
- if (!groups) {
-#if HAVE_FAVOURITE_CONTACTS
- GtkTreeIter iter_group;
-
- 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;
+ tp_connection_parse_object_path (connection, &protocol_name, NULL);
- gtk_tree_model_get (model, &iter,
- EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &c,
- -1);
+ if (!groups) {
+ GtkTreeIter iter_group, *parent;
- if (c == contact) {
- g_object_unref (c);
- return;
- }
- if (c != NULL)
- g_object_unref (c);
- } while (gtk_tree_model_iter_next (model, &iter));
+ parent = &iter_group;
- gtk_tree_store_append (GTK_TREE_STORE (store), &iter, NULL);
-#endif
+ if (!priv->show_groups) {
+ parent = NULL;
+ }
- add_contact_to_store (GTK_TREE_STORE (store), &iter, contact, flags);
+ 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, FALSE);
- gtk_tree_store_insert_after (GTK_TREE_STORE (store), &iter,
- &iter_group, NULL);
-
- add_contact_to_store (GTK_TREE_STORE (store), &iter, contact, flags);
+ add_contact_to_store (GTK_TREE_STORE (store), &iter, &iter_group, contact, flags);
g_free (l->data);
}
g_list_free (groups);
-#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);
}
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);
-}
-
-static gboolean
-list_store_contact_is_favourite (EmpathyContactListStore *store,
- EmpathyContact *contact)
-{
- EmpathyContactListStorePriv *priv;
-
- priv = GET_PRIV (store);
-
- return empathy_contact_list_is_favourite (priv->list, contact);
+ g_hash_table_remove (priv->empathy_contact_cache, contact);
}
static void
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);
}
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;
}
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);
}
} 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) {
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_IS_FAVOURITE, list_store_contact_is_favourite (store, 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,
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);
}
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);
}
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);
}
+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,
ShowActiveData *data;
DEBUG ("Contact:'%s' now active, and %s be removed",
- empathy_contact_get_name (contact),
+ 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);
+ /* 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;
}
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);
}
!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,
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,
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_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);
}
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;
const gchar *name_a,
const gchar *name_b,
EmpathyContact *contact_a,
- EmpathyContact *contact_b)
+ EmpathyContact *contact_b,
+ gboolean fake_group_a,
+ gboolean fake_group_b)
{
if (is_separator_a || is_separator_b) {
/* We have at least one separator */
} else if (contact_a && !contact_b) {
return -1;
} else if (!contact_a && !contact_b) {
- /* Two groups. The 'Ungrouped' fake group is display at the bottom of the
- * contact list and the 'Favorites' at the top. */
- if (!tp_strdiff (name_a, EMPATHY_CONTACT_LIST_STORE_UNGROUPED))
- return 1;
- else if (!tp_strdiff (name_b, EMPATHY_CONTACT_LIST_STORE_UNGROUPED))
- return -1;
- else if (!tp_strdiff (name_a, EMPATHY_CONTACT_LIST_STORE_FAVORITE))
- return -1;
- else if (!tp_strdiff (name_b, EMPATHY_CONTACT_LIST_STORE_FAVORITE))
- return 1;
- else
- return g_utf8_collate (name_a, name_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,
gint ret_val;
gchar *name_a, *name_b;
gboolean is_separator_a, is_separator_b;
- gboolean is_favourite_a, is_favourite_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_FAVOURITE, &is_favourite_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_FAVOURITE, &is_favourite_b,
+ EMPATHY_CONTACT_LIST_STORE_COL_IS_FAKE_GROUP, &fake_group_b,
-1);
- ret_val = compare_separator_and_groups (is_separator_a, is_separator_b,
- name_a, name_b, contact_a, contact_b);
-
- if (ret_val != 0) {
+ 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;
}
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:
gchar *name_a, *name_b;
EmpathyContact *contact_a, *contact_b;
gboolean is_separator_a = FALSE, is_separator_b = FALSE;
- gboolean is_favourite_a, is_favourite_b;
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_FAVOURITE, &is_favourite_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_FAVOURITE, &is_favourite_b,
+ EMPATHY_CONTACT_LIST_STORE_COL_IS_FAKE_GROUP, &fake_group_b,
-1);
- ret_val = compare_separator_and_groups (is_separator_a, is_separator_b,
- name_a, name_b, contact_a, contact_b);
-
- if (ret_val == 0)
- ret_val = g_utf8_collate (name_a, 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);
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
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;
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);
+ }
- status_icon_name = empathy_icon_name_for_contact (contact);
if (status_icon_name == NULL)
return NULL;
projects / empathy.git / blobdiff