libempathy-gtk/empathy-persona-store.c

   1 /*
   2  * Copyright (C) 2005-2007 Imendio AB
   3  * Copyright (C) 2007-2008, 2010 Collabora Ltd.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public
  16  * License along with this program; if not, write to the
  17  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  18  * Boston, MA  02110-1301  USA
  19  *
  20  * Authors: Mikael Hallendal <micke@imendio.com>
  21  *          Martyn Russell <martyn@imendio.com>
  22  *          Xavier Claessens <xclaesse@gmail.com>
  23  *          Philip Withnall <philip.withnall@collabora.co.uk>
  24  *
  25  * Based off EmpathyContactListStore.
  26  */
  27
  28 #include "config.h"
  29
  30 #include <string.h>
  31
  32 #include <glib.h>
  33 #include <glib/gi18n-lib.h>
  34 #include <gtk/gtk.h>
  35
  36 #include <telepathy-glib/util.h>
  37
  38 #include <folks/folks.h>
  39 #include <folks/folks-telepathy.h>
  40
  41 #include <libempathy/empathy-utils.h>
  42
  43 #include "empathy-persona-store.h"
  44 #include "empathy-gtk-enum-types.h"
  45 #include "empathy-ui-utils.h"
  46
  47 #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
  48 #include <libempathy/empathy-debug.h>
  49
  50 /* Active users are those which have recently changed state
  51  * (e.g. online, offline or from normal to a busy state). */
  52
  53 /* Time in seconds user is shown as active */
  54 #define ACTIVE_USER_SHOW_TIME 7
  55
  56 /* Time in seconds after connecting which we wait before active users are
  57  * enabled */
  58 #define ACTIVE_USER_WAIT_TO_ENABLE_TIME 5
  59
  60 static void add_persona (EmpathyPersonaStore *self,
  61     FolksPersona *persona);
  62 static GtkTreePath * find_persona (EmpathyPersonaStore *self,
  63     FolksPersona *persona);
  64 static void update_persona (EmpathyPersonaStore *self,
  65     FolksPersona *persona);
  66 static void remove_persona (EmpathyPersonaStore *self,
  67     FolksPersona *persona);
  68
  69 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyPersonaStore)
  70
  71 typedef struct
  72 {
  73   FolksIndividual *individual; /* owned */
  74   GHashTable *personas; /* owned Persona -> owned GtkTreeRowReference */
  75
  76   gboolean show_avatars;
  77   gboolean show_protocols;
  78   gboolean show_active;
  79   EmpathyPersonaStoreSort sort_criterion;
  80
  81   guint inhibit_active;
  82   guint setup_idle_id;
  83
  84   GHashTable *status_icons; /* owned icon name -> owned GdkPixbuf */
  85 } EmpathyPersonaStorePriv;
  86
  87 enum {
  88   PROP_0,
  89   PROP_INDIVIDUAL,
  90   PROP_SHOW_AVATARS,
  91   PROP_SHOW_PROTOCOLS,
  92   PROP_SORT_CRITERION
  93 };
  94
  95 G_DEFINE_TYPE (EmpathyPersonaStore, empathy_persona_store, GTK_TYPE_LIST_STORE);
  96
  97 static gboolean
  98 inhibit_active_cb (EmpathyPersonaStore *store)
  99 {
 100   EmpathyPersonaStorePriv *priv;
 101
 102   priv = GET_PRIV (store);
 103
 104   priv->show_active = TRUE;
 105   priv->inhibit_active = 0;
 106
 107   return FALSE;
 108 }
 109
 110 typedef struct {
 111   EmpathyPersonaStore *store;
 112   FolksPersona *persona;
 113   gboolean remove;
 114   guint timeout;
 115 } ShowActiveData;
 116
 117 static void persona_active_free (ShowActiveData *data);
 118
 119 static void
 120 persona_active_invalidated (ShowActiveData *data,
 121     GObject *old_object)
 122 {
 123   /* Remove the timeout and free the struct, since the persona or persona
 124    * store has disappeared. */
 125   g_source_remove (data->timeout);
 126
 127   if (old_object == (GObject *) data->store)
 128     data->store = NULL;
 129   else if (old_object == (GObject *) data->persona)
 130     data->persona = NULL;
 131   else
 132     g_assert_not_reached ();
 133
 134   persona_active_free (data);
 135 }
 136
 137 static ShowActiveData *
 138 persona_active_new (EmpathyPersonaStore *self,
 139     FolksPersona *persona,
 140     gboolean remove_)
 141 {
 142   ShowActiveData *data;
 143
 144   DEBUG ("Contact:'%s' now active, and %s be removed",
 145       folks_aliasable_get_alias (FOLKS_ALIASABLE (persona)),
 146       remove_ ? "WILL" : "WILL NOT");
 147
 148   data = g_slice_new0 (ShowActiveData);
 149
 150   /* We don't actually want to force either the PersonaStore or the
 151    * Persona to stay alive, since the user could quit Empathy or disable
 152    * the account before the persona_active timeout is fired. */
 153   g_object_weak_ref (G_OBJECT (self),
 154       (GWeakNotify) persona_active_invalidated, data);
 155   g_object_weak_ref (G_OBJECT (persona),
 156       (GWeakNotify) persona_active_invalidated, data);
 157
 158   data->store = self;
 159   data->persona = persona;
 160   data->remove = remove_;
 161
 162   return data;
 163 }
 164
 165 static void
 166 persona_active_free (ShowActiveData *data)
 167 {
 168   if (data->store != NULL)
 169     {
 170       g_object_weak_unref (G_OBJECT (data->store),
 171           (GWeakNotify) persona_active_invalidated, data);
 172     }
 173
 174   if (data->persona != NULL)
 175     {
 176       g_object_weak_unref (G_OBJECT (data->persona),
 177           (GWeakNotify) persona_active_invalidated, data);
 178     }
 179
 180   g_slice_free (ShowActiveData, data);
 181 }
 182
 183 static void
 184 persona_set_active (EmpathyPersonaStore *self,
 185     FolksPersona *persona,
 186     gboolean active,
 187     gboolean set_changed)
 188 {
 189   EmpathyPersonaStorePriv *priv;
 190   GtkTreePath *path;
 191   GtkTreeIter iter;
 192
 193   priv = GET_PRIV (self);
 194
 195   path = find_persona (self, persona);
 196   if (path == NULL)
 197     return;
 198
 199   gtk_tree_model_get_iter (GTK_TREE_MODEL (self), &iter, path);
 200   gtk_list_store_set (GTK_LIST_STORE (self), &iter,
 201       EMPATHY_PERSONA_STORE_COL_IS_ACTIVE, active,
 202       -1);
 203
 204   DEBUG ("Set item %s", active ? "active" : "inactive");
 205
 206   if (set_changed)
 207     gtk_tree_model_row_changed (GTK_TREE_MODEL (self), path, &iter);
 208
 209   gtk_tree_path_free (path);
 210 }
 211
 212 static gboolean
 213 persona_active_cb (ShowActiveData *data)
 214 {
 215   const gchar *alias =
 216       folks_aliasable_get_alias (FOLKS_ALIASABLE (data->persona));
 217
 218   if (data->remove)
 219     {
 220       DEBUG ("Contact:'%s' active timeout, removing item", alias);
 221       remove_persona (data->store, data->persona);
 222     }
 223
 224   DEBUG ("Contact:'%s' no longer active", alias);
 225   persona_set_active (data->store, data->persona, FALSE, TRUE);
 226
 227   persona_active_free (data);
 228
 229   return FALSE;
 230 }
 231
 232 static void
 233 persona_updated_cb (FolksPersona *persona,
 234     GParamSpec *pspec,
 235     EmpathyPersonaStore *self)
 236 {
 237   DEBUG ("Contact:'%s' updated, checking roster is in sync...",
 238       folks_aliasable_get_alias (FOLKS_ALIASABLE (persona)));
 239
 240   update_persona (self, persona);
 241 }
 242
 243 static void
 244 add_persona_and_connect (EmpathyPersonaStore *self,
 245     FolksPersona *persona)
 246 {
 247   /* We don't want any non-Telepathy personas */
 248   if (!TPF_IS_PERSONA (persona))
 249     return;
 250
 251   g_signal_connect (persona, "notify::presence",
 252       (GCallback) persona_updated_cb, self);
 253   g_signal_connect (persona, "notify::presence-message",
 254       (GCallback) persona_updated_cb, self);
 255   g_signal_connect (persona, "notify::alias",
 256       (GCallback) persona_updated_cb, self);
 257   g_signal_connect (persona, "notify::avatar",
 258       (GCallback) persona_updated_cb, self);
 259
 260   add_persona (self, persona);
 261 }
 262
 263 static void
 264 remove_persona_and_disconnect (EmpathyPersonaStore *self,
 265     FolksPersona *persona)
 266 {
 267   if (!TPF_IS_PERSONA (persona))
 268     return;
 269
 270   g_signal_handlers_disconnect_by_func (persona,
 271       (GCallback) persona_updated_cb, self);
 272
 273   remove_persona (self, persona);
 274 }
 275
 276 static void
 277 add_persona (EmpathyPersonaStore *self,
 278     FolksPersona *persona)
 279 {
 280   EmpathyPersonaStorePriv *priv;
 281   GtkTreeIter iter;
 282   GtkTreePath *path;
 283   FolksPersonaStore *store;
 284   EmpathyContact *contact;
 285   const gchar *alias;
 286
 287   if (!TPF_IS_PERSONA (persona))
 288     return;
 289
 290   priv = GET_PRIV (self);
 291
 292   alias = folks_aliasable_get_alias (FOLKS_ALIASABLE (persona));
 293   if (EMP_STR_EMPTY (alias))
 294     return;
 295
 296   contact = empathy_contact_dup_from_tp_contact (tpf_persona_get_contact (
 297       TPF_PERSONA (persona)));
 298   store = folks_persona_get_store (persona);
 299
 300   gtk_list_store_insert_with_values (GTK_LIST_STORE (self), &iter, 0,
 301       EMPATHY_PERSONA_STORE_COL_NAME, alias,
 302       EMPATHY_PERSONA_STORE_COL_ACCOUNT_NAME,
 303           folks_persona_store_get_display_name (store),
 304       EMPATHY_PERSONA_STORE_COL_DISPLAY_ID,
 305           folks_persona_get_display_id (persona),
 306       EMPATHY_PERSONA_STORE_COL_PERSONA, persona,
 307       EMPATHY_PERSONA_STORE_COL_CAN_AUDIO_CALL,
 308           empathy_contact_get_capabilities (contact) &
 309               EMPATHY_CAPABILITIES_AUDIO,
 310       EMPATHY_PERSONA_STORE_COL_CAN_VIDEO_CALL,
 311           empathy_contact_get_capabilities (contact) &
 312               EMPATHY_CAPABILITIES_VIDEO,
 313       -1);
 314
 315   g_object_unref (contact);
 316
 317   path = gtk_tree_model_get_path (GTK_TREE_MODEL (self), &iter);
 318   g_hash_table_replace (priv->personas, g_object_ref (persona),
 319       gtk_tree_row_reference_new (GTK_TREE_MODEL (self), path));
 320   gtk_tree_path_free (path);
 321
 322   update_persona (self, persona);
 323 }
 324
 325 static void
 326 remove_persona (EmpathyPersonaStore *self,
 327     FolksPersona *persona)
 328 {
 329   EmpathyPersonaStorePriv *priv;
 330   GtkTreePath *path;
 331   GtkTreeIter iter;
 332
 333   if (!TPF_IS_PERSONA (persona))
 334     return;
 335
 336   priv = GET_PRIV (self);
 337
 338   path = find_persona (self, persona);
 339   if (path == NULL)
 340     return;
 341
 342   g_hash_table_remove (priv->personas, persona);
 343
 344   gtk_tree_model_get_iter (GTK_TREE_MODEL (self), &iter, path);
 345   gtk_list_store_remove (GTK_LIST_STORE (self), &iter);
 346   gtk_tree_path_free (path);
 347 }
 348
 349 static GdkPixbuf *
 350 get_persona_status_icon (EmpathyPersonaStore *self,
 351     FolksPersona *persona)
 352 {
 353   EmpathyPersonaStorePriv *priv = GET_PRIV (self);
 354   EmpathyContact *contact;
 355   const gchar *protocol_name = NULL;
 356   gchar *icon_name = NULL;
 357   GdkPixbuf *pixbuf_status = NULL;
 358   const gchar *status_icon_name = NULL;
 359
 360   contact = empathy_contact_dup_from_tp_contact (tpf_persona_get_contact (
 361       TPF_PERSONA (persona)));
 362
 363   status_icon_name = empathy_icon_name_for_contact (contact);
 364   if (status_icon_name == NULL)
 365     {
 366       g_object_unref (contact);
 367       return NULL;
 368     }
 369
 370   if (priv->show_protocols)
 371     {
 372       protocol_name = empathy_protocol_name_for_contact (contact);
 373       icon_name = g_strdup_printf ("%s-%s", status_icon_name, protocol_name);
 374     }
 375   else
 376     {
 377       icon_name = g_strdup_printf ("%s", status_icon_name);
 378     }
 379
 380   pixbuf_status = g_hash_table_lookup (priv->status_icons, icon_name);
 381
 382   if (pixbuf_status == NULL)
 383     {
 384       pixbuf_status = empathy_pixbuf_contact_status_icon_with_icon_name (
 385           contact, status_icon_name, priv->show_protocols);
 386
 387       if (pixbuf_status != NULL)
 388         {
 389           g_hash_table_insert (priv->status_icons, g_strdup (icon_name),
 390               pixbuf_status);
 391         }
 392     }
 393
 394   g_object_unref (contact);
 395   g_free (icon_name);
 396
 397   return pixbuf_status;
 398 }
 399
 400 static void
 401 update_persona (EmpathyPersonaStore *self,
 402     FolksPersona *persona)
 403 {
 404   EmpathyPersonaStorePriv *priv = GET_PRIV (self);
 405   GtkTreePath *path;
 406   gboolean do_set_active = FALSE;
 407   gboolean do_set_refresh = FALSE;
 408   const gchar *alias;
 409
 410   path = find_persona (self, persona);
 411   alias = folks_aliasable_get_alias (FOLKS_ALIASABLE (persona));
 412
 413   if (path == NULL)
 414     {
 415       DEBUG ("Contact:'%s' in list:NO, should be:YES", alias);
 416
 417       add_persona (self, persona);
 418
 419       if (priv->show_active)
 420         {
 421           do_set_active = TRUE;
 422           DEBUG ("Set active (contact added)");
 423         }
 424     }
 425   else
 426     {
 427       FolksPersonaStore *store;
 428       EmpathyContact *contact;
 429       GtkTreeIter iter;
 430       GdkPixbuf *pixbuf_avatar;
 431       GdkPixbuf *pixbuf_status;
 432       gboolean now_online = FALSE;
 433       gboolean was_online = TRUE;
 434
 435       DEBUG ("Contact:'%s' in list:YES, should be:YES", alias);
 436
 437       gtk_tree_model_get_iter (GTK_TREE_MODEL (self), &iter, path);
 438       gtk_tree_path_free (path);
 439
 440       /* Get online state now. */
 441       now_online = folks_presence_owner_is_online (
 442           FOLKS_PRESENCE_OWNER (persona));
 443
 444       /* Get online state before. */
 445       gtk_tree_model_get (GTK_TREE_MODEL (self), &iter,
 446           EMPATHY_PERSONA_STORE_COL_IS_ONLINE, &was_online,
 447           -1);
 448
 449       /* Is this really an update or an online/offline. */
 450       if (priv->show_active)
 451         {
 452           if (was_online != now_online)
 453             {
 454               do_set_active = TRUE;
 455               do_set_refresh = TRUE;
 456
 457               DEBUG ("Set active (contact updated %s)",
 458                   was_online ? "online  -> offline" : "offline -> online");
 459             }
 460           else
 461             {
 462               /* Was TRUE for presence updates. */
 463               /* do_set_active = FALSE;  */
 464               do_set_refresh = TRUE;
 465               DEBUG ("Set active (contact updated)");
 466             }
 467         }
 468
 469       /* We still need to use EmpathyContact for the capabilities stuff */
 470       contact = empathy_contact_dup_from_tp_contact (tpf_persona_get_contact (
 471           TPF_PERSONA (persona)));
 472       store = folks_persona_get_store (persona);
 473
 474       pixbuf_avatar = empathy_pixbuf_avatar_from_contact_scaled (contact,
 475           32, 32);
 476       pixbuf_status = get_persona_status_icon (self, persona);
 477
 478       gtk_list_store_set (GTK_LIST_STORE (self), &iter,
 479           EMPATHY_PERSONA_STORE_COL_ICON_STATUS, pixbuf_status,
 480           EMPATHY_PERSONA_STORE_COL_PIXBUF_AVATAR, pixbuf_avatar,
 481           EMPATHY_PERSONA_STORE_COL_PIXBUF_AVATAR_VISIBLE, priv->show_avatars,
 482           EMPATHY_PERSONA_STORE_COL_NAME, alias,
 483           EMPATHY_PERSONA_STORE_COL_ACCOUNT_NAME,
 484               folks_persona_store_get_display_name (store),
 485           EMPATHY_PERSONA_STORE_COL_DISPLAY_ID,
 486               folks_persona_get_display_id (persona),
 487           EMPATHY_PERSONA_STORE_COL_PRESENCE_TYPE,
 488               folks_presence_owner_get_presence_type (
 489                   FOLKS_PRESENCE_OWNER (persona)),
 490           EMPATHY_PERSONA_STORE_COL_STATUS,
 491               folks_presence_owner_get_presence_message (
 492                   FOLKS_PRESENCE_OWNER (persona)),
 493           EMPATHY_PERSONA_STORE_COL_IS_ONLINE, now_online,
 494           EMPATHY_PERSONA_STORE_COL_CAN_AUDIO_CALL,
 495               empathy_contact_get_capabilities (contact) &
 496                 EMPATHY_CAPABILITIES_AUDIO,
 497           EMPATHY_PERSONA_STORE_COL_CAN_VIDEO_CALL,
 498               empathy_contact_get_capabilities (contact) &
 499                 EMPATHY_CAPABILITIES_VIDEO,
 500           -1);
 501
 502       g_object_unref (contact);
 503
 504       if (pixbuf_avatar)
 505         g_object_unref (pixbuf_avatar);
 506     }
 507
 508   if (priv->show_active && do_set_active)
 509     {
 510       persona_set_active (self, persona, do_set_active, do_set_refresh);
 511
 512       if (do_set_active)
 513         {
 514           ShowActiveData *data;
 515
 516           data = persona_active_new (self, persona, FALSE);
 517           data->timeout = g_timeout_add_seconds (ACTIVE_USER_SHOW_TIME,
 518               (GSourceFunc) persona_active_cb,
 519               data);
 520         }
 521     }
 522
 523   /* FIXME: when someone goes online then offline quickly, the
 524    * first timeout sets the user to be inactive and the second
 525    * timeout removes the user from the contact list, really we
 526    * should remove the first timeout.
 527    */
 528 }
 529
 530 static void
 531 individual_personas_changed_cb (GObject *object,
 532     GList *added,
 533     GList *removed,
 534     EmpathyPersonaStore *self)
 535 {
 536   GList *l;
 537
 538   /* One of the personas' row references might hold the last reference to the
 539    * PersonaStore, so we need to keep a reference ourselves so we don't get
 540    * finalised. */
 541   g_object_ref (self);
 542
 543   /* Remove the old personas. */
 544   for (l = removed; l != NULL; l = l->next)
 545     remove_persona_and_disconnect (self, FOLKS_PERSONA (l->data));
 546
 547   /* Add each of the new personas to the tree model */
 548   for (l = added; l != NULL; l = l->next)
 549     add_persona_and_connect (self, FOLKS_PERSONA (l->data));
 550
 551   g_object_unref (self);
 552 }
 553
 554 static gint
 555 sort_personas (FolksPersona *persona_a,
 556     FolksPersona *persona_b)
 557 {
 558   EmpathyContact *contact;
 559   TpAccount *account_a, *account_b;
 560   gint ret_val;
 561
 562   g_return_val_if_fail (persona_a != NULL || persona_b != NULL, 0);
 563
 564   /* alias */
 565   ret_val = g_utf8_collate (
 566       folks_aliasable_get_alias (FOLKS_ALIASABLE (persona_a)),
 567       folks_aliasable_get_alias (FOLKS_ALIASABLE (persona_b)));
 568
 569   if (ret_val != 0)
 570     goto out;
 571
 572   /* identifier */
 573   ret_val = g_utf8_collate (folks_persona_get_display_id (persona_a),
 574           folks_persona_get_display_id (persona_b));
 575
 576   if (ret_val != 0)
 577     goto out;
 578
 579   contact = empathy_contact_dup_from_tp_contact (tpf_persona_get_contact (
 580       TPF_PERSONA (persona_a)));
 581   account_a = empathy_contact_get_account (contact);
 582   g_object_unref (contact);
 583
 584   contact = empathy_contact_dup_from_tp_contact (tpf_persona_get_contact (
 585       TPF_PERSONA (persona_b)));
 586   account_b = empathy_contact_get_account (contact);
 587   g_object_unref (contact);
 588
 589   /* protocol */
 590   ret_val = strcmp (tp_account_get_protocol (account_a),
 591         tp_account_get_protocol (account_a));
 592
 593   if (ret_val != 0)
 594     goto out;
 595
 596   /* account ID */
 597   ret_val = strcmp (tp_proxy_get_object_path (account_a),
 598         tp_proxy_get_object_path (account_a));
 599
 600 out:
 601   return ret_val;
 602 }
 603
 604 static gint
 605 state_sort_func (GtkTreeModel *model,
 606     GtkTreeIter *iter_a,
 607     GtkTreeIter *iter_b,
 608     gpointer user_data)
 609 {
 610   gint ret_val;
 611   gchar *name_a, *name_b;
 612   FolksPersona *persona_a, *persona_b;
 613
 614   gtk_tree_model_get (model, iter_a,
 615           EMPATHY_PERSONA_STORE_COL_NAME, &name_a,
 616           EMPATHY_PERSONA_STORE_COL_PERSONA, &persona_a,
 617           -1);
 618   gtk_tree_model_get (model, iter_b,
 619           EMPATHY_PERSONA_STORE_COL_NAME, &name_b,
 620           EMPATHY_PERSONA_STORE_COL_PERSONA, &persona_b,
 621           -1);
 622
 623   if (persona_a == NULL || persona_b == NULL) {
 624     ret_val = 0;
 625     goto free_and_out;
 626   }
 627
 628   /* If we managed to get this far, we can start looking at
 629    * the presences.
 630    */
 631   ret_val = -tp_connection_presence_type_cmp_availability (
 632       folks_presence_owner_get_presence_type (FOLKS_PRESENCE_OWNER (persona_a)),
 633       folks_presence_owner_get_presence_type (
 634           FOLKS_PRESENCE_OWNER (persona_b)));
 635
 636   if (ret_val == 0) {
 637     /* Fallback: compare by name et al. */
 638     ret_val = sort_personas (persona_a, persona_b);
 639   }
 640
 641 free_and_out:
 642   g_free (name_a);
 643   g_free (name_b);
 644
 645   tp_clear_object (&persona_a);
 646   tp_clear_object (&persona_b);
 647
 648   return ret_val;
 649 }
 650
 651 static gint
 652 name_sort_func (GtkTreeModel *model,
 653     GtkTreeIter *iter_a,
 654     GtkTreeIter *iter_b,
 655     gpointer user_data)
 656 {
 657   gchar *name_a, *name_b;
 658   FolksPersona *persona_a, *persona_b;
 659   gint ret_val;
 660
 661   gtk_tree_model_get (model, iter_a,
 662           EMPATHY_PERSONA_STORE_COL_NAME, &name_a,
 663           EMPATHY_PERSONA_STORE_COL_PERSONA, &persona_a,
 664           -1);
 665   gtk_tree_model_get (model, iter_b,
 666           EMPATHY_PERSONA_STORE_COL_NAME, &name_b,
 667           EMPATHY_PERSONA_STORE_COL_PERSONA, &persona_b,
 668           -1);
 669
 670   if (persona_a == NULL || persona_b == NULL)
 671     ret_val = 0;
 672   else
 673     ret_val = sort_personas (persona_a, persona_b);
 674
 675   tp_clear_object (&persona_a);
 676   tp_clear_object (&persona_b);
 677
 678   return ret_val;
 679 }
 680
 681 static GtkTreePath *
 682 find_persona (EmpathyPersonaStore *self,
 683     FolksPersona *persona)
 684 {
 685   EmpathyPersonaStorePriv *priv = GET_PRIV (self);
 686   GtkTreeRowReference *row;
 687
 688   row = g_hash_table_lookup (priv->personas, persona);
 689   if (row == NULL)
 690     return NULL;
 691
 692   return gtk_tree_row_reference_get_path (row);
 693 }
 694
 695 static gboolean
 696 update_list_mode_foreach (GtkTreeModel *model,
 697     GtkTreePath *path,
 698     GtkTreeIter *iter,
 699     EmpathyPersonaStore *self)
 700 {
 701   EmpathyPersonaStorePriv *priv;
 702   FolksPersona *persona;
 703   GdkPixbuf *pixbuf_status;
 704
 705   priv = GET_PRIV (self);
 706
 707   gtk_tree_model_get (model, iter,
 708       EMPATHY_PERSONA_STORE_COL_PERSONA, &persona,
 709       -1);
 710
 711   if (persona == NULL)
 712     return FALSE;
 713
 714   /* get icon from hash_table */
 715   pixbuf_status = get_persona_status_icon (self, persona);
 716
 717   gtk_list_store_set (GTK_LIST_STORE (self), iter,
 718       EMPATHY_PERSONA_STORE_COL_ICON_STATUS, pixbuf_status,
 719       EMPATHY_PERSONA_STORE_COL_PIXBUF_AVATAR_VISIBLE, priv->show_avatars,
 720       -1);
 721
 722   tp_clear_object (&persona);
 723
 724   return FALSE;
 725 }
 726
 727 static void
 728 set_up (EmpathyPersonaStore *self)
 729 {
 730   EmpathyPersonaStorePriv *priv;
 731   GType types[] = {
 732     GDK_TYPE_PIXBUF,      /* Status pixbuf */
 733     GDK_TYPE_PIXBUF,      /* Avatar pixbuf */
 734     G_TYPE_BOOLEAN,       /* Avatar pixbuf visible */
 735     G_TYPE_STRING,        /* Name */
 736     G_TYPE_STRING,        /* Account name */
 737     G_TYPE_STRING,        /* Display ID */
 738     G_TYPE_UINT,          /* Presence type */
 739     G_TYPE_STRING,        /* Status string */
 740     FOLKS_TYPE_PERSONA,   /* Persona */
 741     G_TYPE_BOOLEAN,       /* Is active */
 742     G_TYPE_BOOLEAN,       /* Is online */
 743     G_TYPE_BOOLEAN,       /* Can make audio calls */
 744     G_TYPE_BOOLEAN,       /* Can make video calls */
 745   };
 746
 747   priv = GET_PRIV (self);
 748
 749   gtk_list_store_set_column_types (GTK_LIST_STORE (self),
 750       EMPATHY_PERSONA_STORE_COL_COUNT, types);
 751
 752   /* Set up sorting */
 753   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (self),
 754       EMPATHY_PERSONA_STORE_COL_NAME, name_sort_func, self, NULL);
 755   gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (self),
 756       EMPATHY_PERSONA_STORE_COL_STATUS, state_sort_func, self, NULL);
 757
 758   priv->sort_criterion = EMPATHY_PERSONA_STORE_SORT_NAME;
 759   empathy_persona_store_set_sort_criterion (self, priv->sort_criterion);
 760 }
 761
 762 static void
 763 empathy_persona_store_init (EmpathyPersonaStore *self)
 764 {
 765   EmpathyPersonaStorePriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 766       EMPATHY_TYPE_PERSONA_STORE, EmpathyPersonaStorePriv);
 767
 768   self->priv = priv;
 769
 770   priv->show_avatars = TRUE;
 771   priv->show_protocols = FALSE;
 772   priv->inhibit_active = g_timeout_add_seconds (ACTIVE_USER_WAIT_TO_ENABLE_TIME,
 773       (GSourceFunc) inhibit_active_cb, self);
 774
 775   priv->status_icons = g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
 776       g_object_unref);
 777   priv->personas = g_hash_table_new_full (g_direct_hash, g_direct_equal,
 778       g_object_unref, (GDestroyNotify) gtk_tree_row_reference_free);
 779
 780   set_up (self);
 781 }
 782
 783 static void
 784 get_property (GObject *object,
 785     guint param_id,
 786     GValue *value,
 787     GParamSpec *pspec)
 788 {
 789   EmpathyPersonaStorePriv *priv = GET_PRIV (object);
 790
 791   switch (param_id)
 792     {
 793       case PROP_INDIVIDUAL:
 794         g_value_set_object (value, priv->individual);
 795         break;
 796       case PROP_SHOW_AVATARS:
 797         g_value_set_boolean (value, priv->show_avatars);
 798         break;
 799       case PROP_SHOW_PROTOCOLS:
 800         g_value_set_boolean (value, priv->show_protocols);
 801         break;
 802       case PROP_SORT_CRITERION:
 803         g_value_set_enum (value, priv->sort_criterion);
 804         break;
 805       default:
 806         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 807         break;
 808     }
 809 }
 810
 811 static void
 812 set_property (GObject *object,
 813     guint param_id,
 814     const GValue *value,
 815     GParamSpec *pspec)
 816 {
 817   EmpathyPersonaStore *self = EMPATHY_PERSONA_STORE (object);
 818
 819   switch (param_id)
 820     {
 821       case PROP_INDIVIDUAL:
 822         empathy_persona_store_set_individual (self, g_value_get_object (value));
 823         break;
 824       case PROP_SHOW_AVATARS:
 825         empathy_persona_store_set_show_avatars (self,
 826             g_value_get_boolean (value));
 827         break;
 828       case PROP_SHOW_PROTOCOLS:
 829         empathy_persona_store_set_show_protocols (self,
 830             g_value_get_boolean (value));
 831         break;
 832       case PROP_SORT_CRITERION:
 833         empathy_persona_store_set_sort_criterion (self,
 834             g_value_get_enum (value));
 835         break;
 836       default:
 837         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 838         break;
 839     }
 840 }
 841
 842 static void
 843 dispose (GObject *object)
 844 {
 845   EmpathyPersonaStorePriv *priv = GET_PRIV (object);
 846
 847   empathy_persona_store_set_individual (EMPATHY_PERSONA_STORE (object), NULL);
 848
 849   if (priv->inhibit_active != 0)
 850     {
 851       g_source_remove (priv->inhibit_active);
 852       priv->inhibit_active = 0;
 853     }
 854
 855   if (priv->setup_idle_id != 0)
 856     {
 857       g_source_remove (priv->setup_idle_id);
 858       priv->setup_idle_id = 0;
 859     }
 860
 861   G_OBJECT_CLASS (empathy_persona_store_parent_class)->dispose (object);
 862 }
 863
 864 static void
 865 finalize (GObject *object)
 866 {
 867   EmpathyPersonaStorePriv *priv = GET_PRIV (object);
 868
 869   g_hash_table_destroy (priv->status_icons);
 870   g_hash_table_destroy (priv->personas);
 871
 872   G_OBJECT_CLASS (empathy_persona_store_parent_class)->finalize (object);
 873 }
 874
 875 static void
 876 empathy_persona_store_class_init (EmpathyPersonaStoreClass *klass)
 877 {
 878   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 879
 880   object_class->get_property = get_property;
 881   object_class->set_property = set_property;
 882   object_class->dispose = dispose;
 883   object_class->finalize = finalize;
 884
 885   /**
 886    * EmpathyPersonaStore:individual:
 887    *
 888    * The #FolksIndividual whose personas should be listed by the store. This
 889    * may be %NULL, which results in an empty store.
 890    */
 891   g_object_class_install_property (object_class, PROP_INDIVIDUAL,
 892       g_param_spec_object ("individual",
 893           "Individual",
 894           "The FolksIndividual whose Personas should be listed by the store.",
 895           FOLKS_TYPE_INDIVIDUAL,
 896           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 897
 898   /**
 899    * EmpathyPersonaStore:show-avatars:
 900    *
 901    * Whether the store should display avatars for personas. This is a property
 902    * of the store rather than of #EmpathyPersonaView for efficiency reasons.
 903    */
 904   g_object_class_install_property (object_class, PROP_SHOW_AVATARS,
 905       g_param_spec_boolean ("show-avatars",
 906           "Show Avatars",
 907           "Whether the store should display avatars for personas.",
 908           TRUE,
 909           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 910
 911   /**
 912    * EmpathyPersonaStore:show-protocols:
 913    *
 914    * Whether the store should display protocol icons for personas. This is a
 915    * property of the store rather than of #EmpathyPersonaView because it is
 916    * closely tied in with #EmpathyPersonaStore:show-avatars.
 917    */
 918   g_object_class_install_property (object_class, PROP_SHOW_PROTOCOLS,
 919       g_param_spec_boolean ("show-protocols",
 920           "Show Protocols",
 921           "Whether the store should display protocol icons for personas.",
 922           FALSE,
 923           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 924
 925   /**
 926    * EmpathyPersonaStore:sort-criterion:
 927    *
 928    * The criterion used to sort the personas in the store.
 929    */
 930   g_object_class_install_property (object_class, PROP_SORT_CRITERION,
 931       g_param_spec_enum ("sort-criterion",
 932           "Sort criterion",
 933           "The sort criterion to use for sorting the persona list",
 934           EMPATHY_TYPE_PERSONA_STORE_SORT,
 935           EMPATHY_PERSONA_STORE_SORT_NAME,
 936           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 937
 938   g_type_class_add_private (object_class, sizeof (EmpathyPersonaStorePriv));
 939 }
 940
 941 /**
 942  * empathy_persona_store_new:
 943  * @individual: the #FolksIndividual whose personas should be used in the store,
 944  * or %NULL
 945  *
 946  * Create a new #EmpathyPersonaStore with the personas from the given
 947  * @individual.
 948  *
 949  * Return value: a new #EmpathyPersonaStore
 950  */
 951 EmpathyPersonaStore *
 952 empathy_persona_store_new (FolksIndividual *individual)
 953 {
 954   g_return_val_if_fail (individual == NULL || FOLKS_IS_INDIVIDUAL (individual),
 955       NULL);
 956
 957   return g_object_new (EMPATHY_TYPE_PERSONA_STORE,
 958       "individual", individual, NULL);
 959 }
 960
 961 /**
 962  * empathy_persona_store_get_individual:
 963  * @self: an #EmpathyPersonaStore
 964  *
 965  * Get the value of #EmpathyPersonaStore:individual.
 966  *
 967  * Return value: the individual being displayed by the store, or %NULL
 968  */
 969 FolksIndividual *
 970 empathy_persona_store_get_individual (EmpathyPersonaStore *self)
 971 {
 972   g_return_val_if_fail (EMPATHY_IS_PERSONA_STORE (self), NULL);
 973
 974   return GET_PRIV (self)->individual;
 975 }
 976
 977 /**
 978  * empathy_persona_store_set_individual:
 979  * @self: an #EmpathyPersonaStore
 980  * @individual: the new individual to display in the store, or %NULL
 981  *
 982  * Set #EmpathyPersonaStore:individual to @individual, replacing the personas
 983  * which were in the store with the personas belonging to @individual, or with
 984  * nothing if @individual is %NULL.
 985  */
 986 void
 987 empathy_persona_store_set_individual (EmpathyPersonaStore *self,
 988     FolksIndividual *individual)
 989 {
 990   EmpathyPersonaStorePriv *priv;
 991
 992   g_return_if_fail (EMPATHY_IS_PERSONA_STORE (self));
 993   g_return_if_fail (individual == NULL || FOLKS_IS_INDIVIDUAL (individual));
 994
 995   priv = GET_PRIV (self);
 996
 997   /* Remove the old individual */
 998   if (priv->individual != NULL)
 999     {
1000       GList *personas, *l;
1001
1002       g_signal_handlers_disconnect_by_func (priv->individual,
1003           (GCallback) individual_personas_changed_cb, self);
1004
1005       /* Disconnect from and remove all personas belonging to this individual */
1006       personas = folks_individual_get_personas (priv->individual);
1007       for (l = personas; l != NULL; l = l->next)
1008         remove_persona_and_disconnect (self, FOLKS_PERSONA (l->data));
1009
1010       g_object_unref (priv->individual);
1011     }
1012
1013   priv->individual = individual;
1014
1015   /* Add the new individual */
1016   if (individual != NULL)
1017     {
1018       GList *personas, *l;
1019
1020       g_object_ref (individual);
1021
1022       g_signal_connect (individual, "personas-changed",
1023           (GCallback) individual_personas_changed_cb, self);
1024
1025       /* Add pre-existing Personas */
1026       personas = folks_individual_get_personas (individual);
1027       for (l = personas; l != NULL; l = l->next)
1028         add_persona_and_connect (self, FOLKS_PERSONA (l->data));
1029     }
1030
1031   g_object_notify (G_OBJECT (self), "individual");
1032 }
1033
1034 /**
1035  * empathy_persona_store_get_show_avatars:
1036  * @self: an #EmpathyPersonaStore
1037  *
1038  * Get the value of #EmpathyPersonaStore:show-avatars.
1039  *
1040  * Return value: %TRUE if avatars are made available by the store, %FALSE
1041  * otherwise
1042  */
1043 gboolean
1044 empathy_persona_store_get_show_avatars (EmpathyPersonaStore *self)
1045 {
1046   g_return_val_if_fail (EMPATHY_IS_PERSONA_STORE (self), TRUE);
1047
1048   return GET_PRIV (self)->show_avatars;
1049 }
1050
1051 /**
1052  * empathy_persona_store_set_show_avatars:
1053  * @self: an #EmpathyPersonaStore
1054  * @show_avatars: %TRUE to make avatars available through the store, %FALSE
1055  * otherwise
1056  *
1057  * Set #EmpathyPersonaStore:show-avatars to @show_avatars.
1058  */
1059 void
1060 empathy_persona_store_set_show_avatars (EmpathyPersonaStore *self,
1061     gboolean show_avatars)
1062 {
1063   EmpathyPersonaStorePriv *priv;
1064
1065   g_return_if_fail (EMPATHY_IS_PERSONA_STORE (self));
1066
1067   priv = GET_PRIV (self);
1068   priv->show_avatars = show_avatars;
1069
1070   gtk_tree_model_foreach (GTK_TREE_MODEL (self),
1071       (GtkTreeModelForeachFunc) update_list_mode_foreach, self);
1072
1073   g_object_notify (G_OBJECT (self), "show-avatars");
1074 }
1075
1076 /**
1077  * empathy_persona_store_get_show_protocols:
1078  * @self: an #EmpathyPersonaStore
1079  *
1080  * Get the value of #EmpathyPersonaStore:show-protocols.
1081  *
1082  * Return value: %TRUE if protocol images are made available by the store,
1083  * %FALSE otherwise
1084  */
1085 gboolean
1086 empathy_persona_store_get_show_protocols (EmpathyPersonaStore *self)
1087 {
1088   g_return_val_if_fail (EMPATHY_IS_PERSONA_STORE (self), TRUE);
1089
1090   return GET_PRIV (self)->show_protocols;
1091 }
1092
1093 /**
1094  * empathy_persona_store_set_show_protocols:
1095  * @self: an #EmpathyPersonaStore
1096  * @show_protocols: %TRUE to make protocol images available through the store,
1097  * %FALSE otherwise
1098  *
1099  * Set #EmpathyPersonaStore:show-protocols to @show_protocols.
1100  */
1101 void
1102 empathy_persona_store_set_show_protocols (EmpathyPersonaStore *self,
1103     gboolean show_protocols)
1104 {
1105   EmpathyPersonaStorePriv *priv;
1106
1107   g_return_if_fail (EMPATHY_IS_PERSONA_STORE (self));
1108
1109   priv = GET_PRIV (self);
1110   priv->show_protocols = show_protocols;
1111
1112   gtk_tree_model_foreach (GTK_TREE_MODEL (self),
1113       (GtkTreeModelForeachFunc) update_list_mode_foreach, self);
1114
1115   g_object_notify (G_OBJECT (self), "show-protocols");
1116 }
1117
1118 /**
1119  * empathy_persona_store_get_sort_criterion:
1120  * @self: an #EmpathyPersonaStore
1121  *
1122  * Get the value of #EmpathyPersonaStore:sort-criterion.
1123  *
1124  * Return value: the criterion used to sort the personas in the store
1125  */
1126 EmpathyPersonaStoreSort
1127 empathy_persona_store_get_sort_criterion (EmpathyPersonaStore *self)
1128 {
1129   g_return_val_if_fail (EMPATHY_IS_PERSONA_STORE (self), 0);
1130
1131   return GET_PRIV (self)->sort_criterion;
1132 }
1133
1134 /**
1135  * empathy_persona_store_set_sort_criterion:
1136  * @self: an #EmpathyPersonaStore
1137  * @show_avatars: a criterion to be used to sort personas in the store
1138  *
1139  * Set #EmpathyPersonaStore:sort-criterion to @sort_criterion.
1140  */
1141 void
1142 empathy_persona_store_set_sort_criterion (EmpathyPersonaStore *self,
1143     EmpathyPersonaStoreSort sort_criterion)
1144 {
1145   EmpathyPersonaStorePriv *priv;
1146
1147   g_return_if_fail (EMPATHY_IS_PERSONA_STORE (self));
1148
1149   priv = GET_PRIV (self);
1150   priv->sort_criterion = sort_criterion;
1151
1152   switch (sort_criterion)
1153     {
1154       case EMPATHY_PERSONA_STORE_SORT_STATE:
1155         gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self),
1156             EMPATHY_PERSONA_STORE_COL_STATUS, GTK_SORT_ASCENDING);
1157         break;
1158       case EMPATHY_PERSONA_STORE_SORT_NAME:
1159         gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self),
1160             EMPATHY_PERSONA_STORE_COL_NAME, GTK_SORT_ASCENDING);
1161         break;
1162       default:
1163         g_assert_not_reached ();
1164         break;
1165     }
1166
1167   g_object_notify (G_OBJECT (self), "sort-criterion");
1168 }