libempathy-gtk/empathy-roster-view.c

   1 #include "config.h"
   2 #include "empathy-roster-view.h"
   3
   4 #include <glib/gi18n-lib.h>
   5
   6 #include "empathy-contact-groups.h"
   7 #include "empathy-roster-contact.h"
   8 #include "empathy-roster-group.h"
   9 #include "empathy-ui-utils.h"
  10
  11 G_DEFINE_TYPE (EmpathyRosterView, empathy_roster_view, GTK_TYPE_LIST_BOX)
  12
  13 /* Flashing delay for icons (milliseconds). */
  14 #define FLASH_TIMEOUT 500
  15
  16 /* Delay in milliseconds between the last stroke on the keyboard and the start
  17  * of the live search. */
  18 #define SEARCH_TIMEOUT 500
  19
  20 enum
  21 {
  22   PROP_MODEL = 1,
  23   PROP_SHOW_OFFLINE,
  24   PROP_SHOW_GROUPS,
  25   PROP_EMPTY,
  26   N_PROPS
  27 };
  28
  29 enum
  30 {
  31   SIG_INDIVIDUAL_ACTIVATED,
  32   SIG_POPUP_INDIVIDUAL_MENU,
  33   SIG_EVENT_ACTIVATED,
  34   SIG_INDIVIDUAL_TOOLTIP,
  35   LAST_SIGNAL
  36 };
  37
  38 static guint signals[LAST_SIGNAL];
  39
  40 #define NO_GROUP "X-no-group"
  41
  42 struct _EmpathyRosterViewPriv
  43 {
  44   /* FolksIndividual (borrowed) -> GHashTable (
  45    * (gchar * group_name) -> EmpathyRosterContact (borrowed))
  46    *
  47    * When not using groups, this hash just have one element mapped
  48    * from the special NO_GROUP key. We could use it as a set but
  49    * I prefer to stay coherent in the way this hash is managed.
  50    */
  51   GHashTable *roster_contacts;
  52   /* (gchar *group_name) -> EmpathyRosterGroup (borrowed) */
  53   GHashTable *roster_groups;
  54   /* Hash of the EmpathyRosterContact currently displayed */
  55   GHashTable *displayed_contacts;
  56
  57   guint last_event_id;
  58   /* queue of (Event *). The most recent events are in the head of the queue
  59    * so we always display the icon of the oldest one. */
  60   GQueue *events;
  61   guint flash_id;
  62   gboolean display_flash_event;
  63
  64   guint search_id;
  65
  66   gboolean show_offline;
  67   gboolean show_groups;
  68   gboolean empty;
  69
  70   TpawLiveSearch *search;
  71
  72   EmpathyRosterModel *model;
  73 };
  74
  75 /* Prototypes to break cycles */
  76 static void remove_from_group (EmpathyRosterView *self,
  77     FolksIndividual *individual,
  78     const gchar *group);
  79
  80 typedef struct
  81 {
  82   guint id;
  83   FolksIndividual *individual;
  84   gchar *icon;
  85   gpointer user_data;
  86 } Event;
  87
  88 static Event *
  89 event_new (guint id,
  90     FolksIndividual *individual,
  91     const gchar *icon,
  92     gpointer user_data)
  93 {
  94   Event *event = g_slice_new (Event);
  95
  96   event->id = id;
  97   event->individual = g_object_ref (individual);
  98   event->icon = g_strdup (icon);
  99   event->user_data = user_data;
 100   return event;
 101 }
 102
 103 static void
 104 event_free (gpointer data)
 105 {
 106   Event *event = data;
 107   g_object_unref (event->individual);
 108   g_free (event->icon);
 109
 110   g_slice_free (Event, event);
 111 }
 112
 113 static void
 114 empathy_roster_view_get_property (GObject *object,
 115     guint property_id,
 116     GValue *value,
 117     GParamSpec *pspec)
 118 {
 119   EmpathyRosterView *self = EMPATHY_ROSTER_VIEW (object);
 120
 121   switch (property_id)
 122     {
 123       case PROP_MODEL:
 124         g_value_set_object (value, self->priv->model);
 125         break;
 126       case PROP_SHOW_OFFLINE:
 127         g_value_set_boolean (value, self->priv->show_offline);
 128         break;
 129       case PROP_SHOW_GROUPS:
 130         g_value_set_boolean (value, self->priv->show_groups);
 131         break;
 132       case PROP_EMPTY:
 133         g_value_set_boolean (value, self->priv->empty);
 134         break;
 135       default:
 136         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 137         break;
 138     }
 139 }
 140
 141 static void
 142 empathy_roster_view_set_property (GObject *object,
 143     guint property_id,
 144     const GValue *value,
 145     GParamSpec *pspec)
 146 {
 147   EmpathyRosterView *self = EMPATHY_ROSTER_VIEW (object);
 148
 149   switch (property_id)
 150     {
 151       case PROP_MODEL:
 152         g_assert (self->priv->model == NULL);
 153         self->priv->model = g_value_dup_object (value);
 154         break;
 155       case PROP_SHOW_OFFLINE:
 156         empathy_roster_view_show_offline (self, g_value_get_boolean (value));
 157         break;
 158       case PROP_SHOW_GROUPS:
 159         empathy_roster_view_show_groups (self, g_value_get_boolean (value));
 160         break;
 161       default:
 162         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 163         break;
 164     }
 165 }
 166
 167 static void
 168 roster_contact_changed_cb (GtkListBoxRow *child,
 169     GParamSpec *spec,
 170     EmpathyRosterView *self)
 171 {
 172   gtk_list_box_row_changed (child);
 173 }
 174
 175 static GtkWidget *
 176 add_roster_contact (EmpathyRosterView *self,
 177     FolksIndividual *individual,
 178     const gchar *group)
 179 {
 180   GtkWidget *contact;
 181
 182   contact = empathy_roster_contact_new (individual, group);
 183
 184   /* Need to refilter if online is changed */
 185   g_signal_connect (contact, "notify::online",
 186       G_CALLBACK (roster_contact_changed_cb), self);
 187
 188   /* Need to resort if alias is changed */
 189   g_signal_connect (contact, "notify::alias",
 190       G_CALLBACK (roster_contact_changed_cb), self);
 191
 192   /* Need to resort if most recent event changed */
 193   g_signal_connect (contact, "notify::most-recent-event",
 194       G_CALLBACK (roster_contact_changed_cb), self);
 195
 196   gtk_widget_show (contact);
 197   gtk_container_add (GTK_CONTAINER (self), contact);
 198
 199   return contact;
 200 }
 201
 202 static void
 203 group_expanded_cb (GtkWidget *expander,
 204     GParamSpec *spec,
 205     EmpathyRosterGroup *group)
 206 {
 207   GList *widgets, *l;
 208
 209   widgets = empathy_roster_group_get_widgets (group);
 210   for (l = widgets; l != NULL; l = g_list_next (l))
 211     {
 212       gtk_list_box_row_changed (l->data);
 213     }
 214
 215   g_list_free (widgets);
 216
 217   empathy_contact_group_set_expanded (empathy_roster_group_get_name (group),
 218       gtk_expander_get_expanded (group->expander));
 219 }
 220
 221 static EmpathyRosterGroup *
 222 lookup_roster_group (EmpathyRosterView *self,
 223     const gchar *group)
 224 {
 225   return g_hash_table_lookup (self->priv->roster_groups, group);
 226 }
 227
 228 static EmpathyRosterGroup *
 229 ensure_roster_group (EmpathyRosterView *self,
 230     const gchar *group)
 231 {
 232   GtkWidget *roster_group;
 233
 234   roster_group = (GtkWidget *) lookup_roster_group (self, group);
 235   if (roster_group != NULL)
 236     return EMPATHY_ROSTER_GROUP (roster_group);
 237
 238   if (!tp_strdiff (group, EMPATHY_ROSTER_MODEL_GROUP_TOP_GROUP))
 239     roster_group = empathy_roster_group_new (group, "emblem-favorite-symbolic");
 240   else if (!tp_strdiff (group, EMPATHY_ROSTER_MODEL_GROUP_PEOPLE_NEARBY))
 241     roster_group = empathy_roster_group_new (group, "im-local-xmpp");
 242   else
 243     roster_group = empathy_roster_group_new (group, NULL);
 244
 245   gtk_expander_set_expanded (EMPATHY_ROSTER_GROUP (roster_group)->expander,
 246       empathy_contact_group_get_expanded (group));
 247
 248   g_signal_connect (EMPATHY_ROSTER_GROUP (roster_group)->expander,
 249       "notify::expanded", G_CALLBACK (group_expanded_cb), roster_group);
 250
 251   gtk_widget_show (roster_group);
 252   gtk_container_add (GTK_CONTAINER (self), roster_group);
 253
 254   g_hash_table_insert (self->priv->roster_groups, g_strdup (group),
 255       roster_group);
 256
 257   return EMPATHY_ROSTER_GROUP (roster_group);
 258 }
 259
 260 static void
 261 update_empty (EmpathyRosterView *self,
 262     gboolean empty)
 263 {
 264   if (self->priv->empty == empty)
 265     return;
 266
 267   self->priv->empty = empty;
 268   g_object_notify (G_OBJECT (self), "empty");
 269 }
 270
 271 static gboolean filter_group (EmpathyRosterView *self,
 272     EmpathyRosterGroup *group);
 273
 274 static gboolean
 275 at_least_one_group_displayed (EmpathyRosterView *self)
 276 {
 277   GHashTableIter iter;
 278   gpointer v;
 279
 280   g_hash_table_iter_init (&iter, self->priv->roster_groups);
 281   while (g_hash_table_iter_next (&iter, NULL, &v))
 282     {
 283       EmpathyRosterGroup *group = EMPATHY_ROSTER_GROUP (v);
 284
 285       if (filter_group (self, group))
 286         return TRUE;
 287     }
 288
 289   return FALSE;
 290 }
 291
 292 static void
 293 check_if_empty (EmpathyRosterView *self)
 294 {
 295   /* Roster is considered as empty if there is no contact *and* no group
 296    * currently displayed. */
 297   if (g_hash_table_size (self->priv->displayed_contacts) != 0 ||
 298       at_least_one_group_displayed (self))
 299     {
 300       update_empty (self, FALSE);
 301       return;
 302     }
 303
 304   update_empty (self, TRUE);
 305 }
 306
 307 static void
 308 update_group_widgets (EmpathyRosterView *self,
 309     EmpathyRosterGroup *group,
 310     EmpathyRosterContact *contact,
 311     gboolean add)
 312 {
 313   guint old_count, count;
 314
 315   old_count = empathy_roster_group_get_widgets_count (group);
 316
 317   if (add)
 318     count = empathy_roster_group_add_widget (group, GTK_WIDGET (contact));
 319   else
 320     count = empathy_roster_group_remove_widget (group, GTK_WIDGET (contact));
 321
 322   if (count != old_count)
 323     {
 324       gtk_list_box_row_changed (GTK_LIST_BOX_ROW (group));
 325
 326       check_if_empty (self);
 327     }
 328 }
 329
 330 static void
 331 add_to_group (EmpathyRosterView *self,
 332     FolksIndividual *individual,
 333     const gchar *group)
 334 {
 335   GtkWidget *contact;
 336   GHashTable *contacts;
 337   EmpathyRosterGroup *roster_group = NULL;
 338
 339   contacts = g_hash_table_lookup (self->priv->roster_contacts, individual);
 340   if (contacts == NULL)
 341     return;
 342
 343   if (g_hash_table_lookup (contacts, group) != NULL)
 344     return;
 345
 346   if (tp_strdiff (group, NO_GROUP))
 347     roster_group = ensure_roster_group (self, group);
 348
 349   contact = add_roster_contact (self, individual, group);
 350   g_hash_table_insert (contacts, g_strdup (group), contact);
 351
 352   if (roster_group != NULL)
 353     {
 354       update_group_widgets (self, roster_group,
 355           EMPATHY_ROSTER_CONTACT (contact), TRUE);
 356     }
 357
 358   if (tp_strdiff (group, NO_GROUP) &&
 359       tp_strdiff (group, EMPATHY_ROSTER_MODEL_GROUP_UNGROUPED) &&
 360       g_hash_table_size (contacts) == 2 /* 1:Ungrouped and 2:first group */)
 361     {
 362       remove_from_group (self, individual,
 363           EMPATHY_ROSTER_MODEL_GROUP_UNGROUPED);
 364     }
 365 }
 366
 367 static void
 368 individual_favourite_change_cb (FolksIndividual *individual,
 369     GParamSpec *spec,
 370     EmpathyRosterView *self)
 371 {
 372   /* We may have to refilter the contact as only favorite contacts are always
 373    * displayed regardless of their presence. */
 374   GHashTable *contacts;
 375   GtkWidget *contact;
 376
 377   contacts = g_hash_table_lookup (self->priv->roster_contacts, individual);
 378   if (contacts == NULL)
 379     return;
 380
 381   if (self->priv->show_groups)
 382     contact = g_hash_table_lookup (contacts,
 383         EMPATHY_ROSTER_MODEL_GROUP_TOP_GROUP);
 384   else
 385     contact = g_hash_table_lookup (contacts, NO_GROUP);
 386
 387   if (contact == NULL)
 388     return;
 389
 390   gtk_list_box_row_changed (GTK_LIST_BOX_ROW (contact));
 391 }
 392
 393 static void
 394 individual_added (EmpathyRosterView *self,
 395     FolksIndividual *individual)
 396 {
 397   GHashTable *contacts;
 398
 399   contacts = g_hash_table_lookup (self->priv->roster_contacts, individual);
 400   if (contacts != NULL)
 401     return;
 402
 403   contacts = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
 404
 405   g_hash_table_insert (self->priv->roster_contacts, individual, contacts);
 406
 407   if (!self->priv->show_groups)
 408     {
 409       add_to_group (self, individual, NO_GROUP);
 410     }
 411   else
 412     {
 413       GList *groups, *l;
 414
 415       groups = empathy_roster_model_dup_groups_for_individual (self->priv->model,
 416           individual);
 417
 418       if (g_list_length (groups) > 0)
 419         {
 420           for (l = groups; l != NULL; l = g_list_next (l))
 421             {
 422               add_to_group (self, individual, l->data);
 423             }
 424         }
 425       else
 426         {
 427           /* No group, adds to Ungrouped */
 428           add_to_group (self, individual, EMPATHY_ROSTER_MODEL_GROUP_UNGROUPED);
 429         }
 430
 431       g_list_free_full (groups, g_free);
 432     }
 433
 434   tp_g_signal_connect_object (individual, "notify::is-favourite",
 435       G_CALLBACK (individual_favourite_change_cb), self, 0);
 436 }
 437
 438 static void
 439 set_event_icon_on_individual (EmpathyRosterView *self,
 440     FolksIndividual *individual,
 441     const gchar *icon)
 442 {
 443   GHashTable *contacts;
 444   GHashTableIter iter;
 445   gpointer v;
 446
 447   contacts = g_hash_table_lookup (self->priv->roster_contacts, individual);
 448   if (contacts == NULL)
 449     return;
 450
 451   g_hash_table_iter_init (&iter, contacts);
 452   while (g_hash_table_iter_next (&iter, NULL, &v))
 453     {
 454       EmpathyRosterContact *contact =v;
 455
 456       empathy_roster_contact_set_event_icon (contact, icon);
 457     }
 458 }
 459
 460 static void
 461 flash_event (Event *event,
 462     EmpathyRosterView *self)
 463 {
 464   set_event_icon_on_individual (self, event->individual, event->icon);
 465 }
 466
 467 static void
 468 unflash_event (Event *event,
 469     EmpathyRosterView *self)
 470 {
 471   set_event_icon_on_individual (self, event->individual, NULL);
 472 }
 473
 474 static gboolean
 475 flash_cb (gpointer data)
 476 {
 477   EmpathyRosterView *self = data;
 478
 479   if (self->priv->display_flash_event)
 480     {
 481       g_queue_foreach (self->priv->events, (GFunc) flash_event, self);
 482       self->priv->display_flash_event = FALSE;
 483     }
 484   else
 485     {
 486       g_queue_foreach (self->priv->events, (GFunc) unflash_event, self);
 487       self->priv->display_flash_event = TRUE;
 488     }
 489
 490   return TRUE;
 491 }
 492
 493 static void
 494 start_flashing (EmpathyRosterView *self)
 495 {
 496   if (self->priv->flash_id != 0)
 497     return;
 498
 499   self->priv->display_flash_event = TRUE;
 500
 501   self->priv->flash_id = g_timeout_add (FLASH_TIMEOUT,
 502       flash_cb, self);
 503 }
 504
 505 static void
 506 stop_flashing (EmpathyRosterView *self)
 507 {
 508   if (self->priv->flash_id == 0)
 509     return;
 510
 511   g_source_remove (self->priv->flash_id);
 512   self->priv->flash_id = 0;
 513 }
 514
 515 static void
 516 remove_event (EmpathyRosterView *self,
 517     Event *event)
 518 {
 519   unflash_event (event, self);
 520   g_queue_remove (self->priv->events, event);
 521
 522   if (g_queue_get_length (self->priv->events) == 0)
 523     {
 524       stop_flashing (self);
 525     }
 526 }
 527
 528 static void
 529 remove_all_individual_event (EmpathyRosterView *self,
 530     FolksIndividual *individual)
 531 {
 532   GList *l;
 533
 534   for (l = g_queue_peek_head_link (self->priv->events); l != NULL;
 535       l = g_list_next (l))
 536     {
 537       Event *event = l->data;
 538
 539       if (event->individual == individual)
 540         {
 541           remove_event (self, event);
 542           return;
 543         }
 544     }
 545 }
 546
 547 static void
 548 individual_removed (EmpathyRosterView *self,
 549     FolksIndividual *individual)
 550 {
 551   GHashTable *contacts;
 552   GHashTableIter iter;
 553   gpointer key, value;
 554
 555   contacts = g_hash_table_lookup (self->priv->roster_contacts, individual);
 556   if (contacts == NULL)
 557     return;
 558
 559   remove_all_individual_event (self, individual);
 560
 561   g_hash_table_iter_init (&iter, contacts);
 562   while (g_hash_table_iter_next (&iter, &key, &value))
 563     {
 564       const gchar *group_name = key;
 565       GtkWidget *contact = value;
 566       EmpathyRosterGroup *group;
 567
 568       group = lookup_roster_group (self, group_name);
 569       if (group != NULL)
 570         {
 571           update_group_widgets (self, group,
 572               EMPATHY_ROSTER_CONTACT (contact), FALSE);
 573         }
 574
 575       gtk_container_remove (GTK_CONTAINER (self), contact);
 576     }
 577
 578   g_hash_table_remove (self->priv->roster_contacts, individual);
 579 }
 580
 581 static void
 582 individual_added_cb (EmpathyRosterModel *model,
 583     FolksIndividual *individual,
 584     EmpathyRosterView *self)
 585 {
 586   individual_added (self, individual);
 587 }
 588
 589 static void
 590 individual_removed_cb (EmpathyRosterModel *model,
 591     FolksIndividual *individual,
 592     EmpathyRosterView *self)
 593 {
 594   individual_removed (self, individual);
 595 }
 596
 597 static gboolean
 598 contact_in_top (EmpathyRosterView *self,
 599     EmpathyRosterContact *contact)
 600 {
 601   if (!self->priv->show_groups)
 602     {
 603       /* Always display top contacts in non-group mode. */
 604       GList *groups;
 605       FolksIndividual *individual;
 606       gboolean result = FALSE;
 607
 608       individual = empathy_roster_contact_get_individual (contact);
 609
 610       groups = empathy_roster_model_dup_groups_for_individual (
 611           self->priv->model, individual);
 612
 613       if (g_list_find_custom (groups, EMPATHY_ROSTER_MODEL_GROUP_TOP_GROUP,
 614             (GCompareFunc) g_strcmp0) != NULL)
 615         result = TRUE;
 616
 617       g_list_free_full (groups, g_free);
 618
 619       return result;
 620     }
 621
 622   if (!tp_strdiff (empathy_roster_contact_get_group (contact),
 623           EMPATHY_ROSTER_MODEL_GROUP_TOP_GROUP))
 624     /* If we are displaying contacts, we only want to *always* display the
 625      * RosterContact which is displayed at the top; not the ones displayed in
 626      * the 'normal' group sections */
 627     return TRUE;
 628
 629   return FALSE;
 630 }
 631
 632 static gint
 633 compare_roster_contacts_by_conversation_time (EmpathyRosterContact *a,
 634     EmpathyRosterContact *b)
 635 {
 636   gint64 ts_a, ts_b;
 637
 638   ts_a = empathy_roster_contact_get_most_recent_timestamp (a);
 639   ts_b = empathy_roster_contact_get_most_recent_timestamp (b);
 640
 641   if (ts_a == ts_b) return 0;
 642   if (ts_a > ts_b) return -1;
 643   return 1;
 644 }
 645
 646 static gint
 647 compare_roster_contacts_by_alias (EmpathyRosterContact *a,
 648     EmpathyRosterContact *b)
 649 {
 650   FolksIndividual *ind_a, *ind_b;
 651   const gchar *alias_a, *alias_b;
 652
 653   ind_a = empathy_roster_contact_get_individual (a);
 654   ind_b = empathy_roster_contact_get_individual (b);
 655
 656   alias_a = folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (ind_a));
 657   alias_b = folks_alias_details_get_alias (FOLKS_ALIAS_DETAILS (ind_b));
 658
 659   return g_utf8_collate (alias_a, alias_b);
 660 }
 661
 662 static gint
 663 compare_roster_contacts_no_group (EmpathyRosterView *self,
 664     EmpathyRosterContact *a,
 665     EmpathyRosterContact *b)
 666 {
 667   gboolean top_a, top_b;
 668
 669   top_a = contact_in_top (self, a);
 670   top_b = contact_in_top (self, b);
 671
 672   if (top_a == top_b)
 673     /* Both contacts are in the top of the roster (or not). Sort them
 674      * alphabetically */
 675     return compare_roster_contacts_by_conversation_time (a, b);
 676   else if (top_a)
 677     return -1;
 678   else
 679     return 1;
 680 }
 681
 682 static gint
 683 compare_group_names (const gchar *group_a,
 684     const gchar *group_b)
 685 {
 686   if (!tp_strdiff (group_a, EMPATHY_ROSTER_MODEL_GROUP_TOP_GROUP))
 687     return -1;
 688
 689   if (!tp_strdiff (group_b, EMPATHY_ROSTER_MODEL_GROUP_TOP_GROUP))
 690     return 1;
 691
 692   if (!tp_strdiff (group_a, EMPATHY_ROSTER_MODEL_GROUP_UNGROUPED))
 693     return 1;
 694   else if (!tp_strdiff (group_b, EMPATHY_ROSTER_MODEL_GROUP_UNGROUPED))
 695     return -1;
 696
 697   return g_utf8_collate (group_a, group_b);
 698 }
 699
 700 static gint
 701 compare_roster_contacts_with_groups (EmpathyRosterView *self,
 702     EmpathyRosterContact *a,
 703     EmpathyRosterContact *b)
 704 {
 705   const gchar *group_a, *group_b;
 706
 707   group_a = empathy_roster_contact_get_group (a);
 708   group_b = empathy_roster_contact_get_group (b);
 709
 710   if (!tp_strdiff (group_a, group_b))
 711     /* Same group, compare the contacts */
 712     return compare_roster_contacts_by_conversation_time (a, b);
 713
 714   /* Sort by group */
 715   return compare_group_names (group_a, group_b);
 716 }
 717
 718 static gint
 719 compare_roster_contacts (EmpathyRosterView *self,
 720     EmpathyRosterContact *a,
 721     EmpathyRosterContact *b)
 722 {
 723   if (!self->priv->show_groups)
 724     return compare_roster_contacts_no_group (self, a, b);
 725   else
 726     return compare_roster_contacts_with_groups (self, a, b);
 727 }
 728
 729 static gint
 730 compare_roster_groups (EmpathyRosterGroup *a,
 731     EmpathyRosterGroup *b)
 732 {
 733   const gchar *name_a, *name_b;
 734
 735   name_a = empathy_roster_group_get_name (a);
 736   name_b = empathy_roster_group_get_name (b);
 737
 738   return compare_group_names (name_a, name_b);
 739 }
 740
 741 static gint
 742 compare_contact_group (EmpathyRosterContact *contact,
 743     EmpathyRosterGroup *group)
 744 {
 745   const char *contact_group, *group_name;
 746
 747   contact_group = empathy_roster_contact_get_group (contact);
 748   group_name = empathy_roster_group_get_name (group);
 749
 750   if (!tp_strdiff (contact_group, group_name))
 751     /* @contact is in @group, @group has to be displayed first */
 752     return 1;
 753
 754   /* @contact is in a different group, sort by group name */
 755   return compare_group_names (contact_group, group_name);
 756 }
 757
 758 static gint
 759 roster_view_sort (GtkListBoxRow *a,
 760     GtkListBoxRow *b,
 761     gpointer user_data)
 762 {
 763   EmpathyRosterView *self = user_data;
 764
 765   if (EMPATHY_IS_ROSTER_CONTACT (a) && EMPATHY_IS_ROSTER_CONTACT (b))
 766     return compare_roster_contacts (self, EMPATHY_ROSTER_CONTACT (a),
 767         EMPATHY_ROSTER_CONTACT (b));
 768   else if (EMPATHY_IS_ROSTER_GROUP (a) && EMPATHY_IS_ROSTER_GROUP (b))
 769     return compare_roster_groups (EMPATHY_ROSTER_GROUP (a),
 770         EMPATHY_ROSTER_GROUP (b));
 771   else if (EMPATHY_IS_ROSTER_CONTACT (a) && EMPATHY_IS_ROSTER_GROUP (b))
 772     return compare_contact_group (EMPATHY_ROSTER_CONTACT (a),
 773         EMPATHY_ROSTER_GROUP (b));
 774   else if (EMPATHY_IS_ROSTER_GROUP (a) && EMPATHY_IS_ROSTER_CONTACT (b))
 775     return -1 * compare_contact_group (EMPATHY_ROSTER_CONTACT (b),
 776         EMPATHY_ROSTER_GROUP (a));
 777
 778   g_return_val_if_reached (0);
 779 }
 780
 781 static void
 782 update_header (GtkListBoxRow *row,
 783     GtkListBoxRow *before,
 784     gpointer user_data)
 785 {
 786   if (before == NULL)
 787     {
 788       /* No separator before the first row */
 789       gtk_list_box_row_set_header (row, NULL);
 790       return;
 791     }
 792
 793   if (gtk_list_box_row_get_header (row) != NULL)
 794     return;
 795
 796   gtk_list_box_row_set_header (row,
 797       gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
 798 }
 799
 800 static gboolean
 801 is_searching (EmpathyRosterView *self)
 802 {
 803   if (self->priv->search == NULL)
 804     return FALSE;
 805
 806   return gtk_widget_get_visible (GTK_WIDGET (self->priv->search));
 807 }
 808
 809 static void
 810 add_to_displayed (EmpathyRosterView *self,
 811     EmpathyRosterContact *contact)
 812 {
 813   FolksIndividual *individual;
 814   GHashTable *contacts;
 815   GHashTableIter iter;
 816   gpointer k;
 817
 818   if (g_hash_table_lookup (self->priv->displayed_contacts, contact) != NULL)
 819     return;
 820
 821   g_hash_table_add (self->priv->displayed_contacts, contact);
 822   update_empty (self, FALSE);
 823
 824   /* Groups of this contact may now be displayed if we just displays the first
 825    * child in this group. */
 826
 827   if (!self->priv->show_groups)
 828     return;
 829
 830   individual = empathy_roster_contact_get_individual (contact);
 831   contacts = g_hash_table_lookup (self->priv->roster_contacts, individual);
 832   if (contacts == NULL)
 833     return;
 834
 835   g_hash_table_iter_init (&iter, contacts);
 836   while (g_hash_table_iter_next (&iter, &k, NULL))
 837     {
 838       const gchar *group_name = k;
 839       GtkListBoxRow *group;
 840
 841       group = g_hash_table_lookup (self->priv->roster_groups, group_name);
 842       if (group == NULL)
 843         continue;
 844
 845       gtk_list_box_row_changed (group);
 846     }
 847 }
 848
 849 static void
 850 remove_from_displayed (EmpathyRosterView *self,
 851     EmpathyRosterContact *contact)
 852 {
 853   g_hash_table_remove (self->priv->displayed_contacts, contact);
 854
 855   check_if_empty (self);
 856 }
 857
 858 static gboolean
 859 contact_is_favorite (EmpathyRosterContact *contact)
 860 {
 861   FolksIndividual *individual;
 862
 863   individual = empathy_roster_contact_get_individual (contact);
 864
 865   return folks_favourite_details_get_is_favourite (
 866       FOLKS_FAVOURITE_DETAILS (individual));
 867 }
 868
 869 /**
 870  * check if @contact should be displayed according to @self's current status
 871  * and without consideration for the state of @contact's groups.
 872  */
 873 static gboolean
 874 contact_should_be_displayed (EmpathyRosterView *self,
 875     EmpathyRosterContact *contact)
 876 {
 877   if (is_searching (self))
 878     {
 879       FolksIndividual *individual;
 880
 881       individual = empathy_roster_contact_get_individual (contact);
 882
 883       return empathy_individual_match_string (individual,
 884           tpaw_live_search_get_text (self->priv->search),
 885           tpaw_live_search_get_words (self->priv->search));
 886     }
 887
 888   if (self->priv->show_offline)
 889       return TRUE;
 890
 891   if (contact_in_top (self, contact) &&
 892       contact_is_favorite (contact))
 893     /* Favorite top contacts are always displayed */
 894     return TRUE;
 895
 896   return empathy_roster_contact_is_online (contact);
 897 }
 898
 899
 900 static gboolean
 901 filter_contact (EmpathyRosterView *self,
 902     EmpathyRosterContact *contact)
 903 {
 904   gboolean displayed;
 905
 906   displayed = contact_should_be_displayed (self, contact);
 907
 908   if (self->priv->show_groups)
 909     {
 910       const gchar *group_name;
 911       EmpathyRosterGroup *group;
 912
 913       group_name = empathy_roster_contact_get_group (contact);
 914       group = lookup_roster_group (self, group_name);
 915
 916       if (group != NULL)
 917         {
 918           /* When searching, always display even if the group is closed */
 919           if (!is_searching (self) &&
 920               !gtk_expander_get_expanded (group->expander))
 921             displayed = FALSE;
 922         }
 923     }
 924
 925   if (displayed)
 926     {
 927       add_to_displayed (self, contact);
 928     }
 929   else
 930     {
 931       remove_from_displayed (self, contact);
 932     }
 933
 934   return displayed;
 935 }
 936
 937 static gboolean
 938 filter_group (EmpathyRosterView *self,
 939     EmpathyRosterGroup *group)
 940 {
 941   GList *widgets, *l;
 942   gboolean result = FALSE;
 943
 944   /* Display the group if it contains at least one displayed contact */
 945   widgets = empathy_roster_group_get_widgets (group);
 946   for (l = widgets; l != NULL; l = g_list_next (l))
 947     {
 948       EmpathyRosterContact *contact = l->data;
 949
 950       if (contact_should_be_displayed (self, contact))
 951         {
 952           result = TRUE;
 953           break;
 954         }
 955     }
 956
 957   g_list_free (widgets);
 958
 959   return result;
 960 }
 961
 962 static gboolean
 963 filter_list (GtkListBoxRow *child,
 964     gpointer user_data)
 965 {
 966   EmpathyRosterView *self = user_data;
 967
 968   if (EMPATHY_IS_ROSTER_CONTACT (child))
 969     return filter_contact (self, EMPATHY_ROSTER_CONTACT (child));
 970
 971   else if (EMPATHY_IS_ROSTER_GROUP (child))
 972     return filter_group (self, EMPATHY_ROSTER_GROUP (child));
 973
 974   g_return_val_if_reached (FALSE);
 975 }
 976
 977 static void
 978 populate_view (EmpathyRosterView *self)
 979 {
 980   GList *individuals, *l;
 981
 982   individuals = empathy_roster_model_get_individuals (self->priv->model);
 983   for (l = individuals; l != NULL; l = g_list_next (l))
 984     {
 985       FolksIndividual *individual = l->data;
 986
 987       individual_added (self, individual);
 988     }
 989
 990   g_list_free (individuals);
 991 }
 992
 993 static void
 994 remove_from_group (EmpathyRosterView *self,
 995     FolksIndividual *individual,
 996     const gchar *group)
 997 {
 998   GHashTable *contacts;
 999   GtkWidget *contact;
1000   EmpathyRosterGroup *roster_group;
1001
1002   contacts = g_hash_table_lookup (self->priv->roster_contacts, individual);
1003   if (contacts == NULL)
1004     return;
1005
1006   contact = g_hash_table_lookup (contacts, group);
1007   if (contact == NULL)
1008     return;
1009
1010   g_hash_table_remove (contacts, group);
1011
1012   if (g_hash_table_size (contacts) == 0)
1013     {
1014       add_to_group (self, individual, EMPATHY_ROSTER_MODEL_GROUP_UNGROUPED);
1015     }
1016
1017   roster_group = lookup_roster_group (self, group);
1018
1019   if (roster_group != NULL)
1020     {
1021       update_group_widgets (self, roster_group,
1022           EMPATHY_ROSTER_CONTACT (contact), FALSE);
1023     }
1024
1025   gtk_container_remove (GTK_CONTAINER (self), contact);
1026 }
1027
1028 static void
1029 groups_changed_cb (EmpathyRosterModel *model,
1030     FolksIndividual *individual,
1031     const gchar *group,
1032     gboolean is_member,
1033     EmpathyRosterView *self)
1034 {
1035   if (!self->priv->show_groups)
1036     {
1037       gtk_list_box_invalidate_sort (GTK_LIST_BOX (self));
1038       return;
1039     }
1040
1041   if (is_member)
1042     {
1043       add_to_group (self, individual, group);
1044     }
1045   else
1046     {
1047       remove_from_group (self, individual, group);
1048     }
1049 }
1050
1051 static void
1052 empathy_roster_view_constructed (GObject *object)
1053 {
1054   EmpathyRosterView *self = EMPATHY_ROSTER_VIEW (object);
1055   void (*chain_up) (GObject *) =
1056       ((GObjectClass *) empathy_roster_view_parent_class)->constructed;
1057
1058   if (chain_up != NULL)
1059     chain_up (object);
1060
1061   g_assert (EMPATHY_IS_ROSTER_MODEL (self->priv->model));
1062
1063   /* Get saved group states. */
1064   empathy_contact_groups_get_all ();
1065
1066   populate_view (self);
1067
1068   tp_g_signal_connect_object (self->priv->model, "individual-added",
1069       G_CALLBACK (individual_added_cb), self, 0);
1070   tp_g_signal_connect_object (self->priv->model, "individual-removed",
1071       G_CALLBACK (individual_removed_cb), self, 0);
1072   tp_g_signal_connect_object (self->priv->model, "groups-changed",
1073       G_CALLBACK (groups_changed_cb), self, 0);
1074
1075   gtk_list_box_set_sort_func (GTK_LIST_BOX (self),
1076       roster_view_sort, self, NULL);
1077
1078   gtk_list_box_set_header_func (GTK_LIST_BOX (self), update_header, self, NULL);
1079
1080   gtk_list_box_set_filter_func (GTK_LIST_BOX (self), filter_list, self, NULL);
1081
1082   gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (self), FALSE);
1083 }
1084
1085 static void
1086 clear_view (EmpathyRosterView *self)
1087 {
1088   g_hash_table_remove_all (self->priv->roster_contacts);
1089   g_hash_table_remove_all (self->priv->roster_groups);
1090   g_hash_table_remove_all (self->priv->displayed_contacts);
1091
1092   gtk_container_foreach (GTK_CONTAINER (self),
1093       (GtkCallback) gtk_widget_destroy, NULL);
1094 }
1095
1096 static void
1097 empathy_roster_view_dispose (GObject *object)
1098 {
1099   EmpathyRosterView *self = EMPATHY_ROSTER_VIEW (object);
1100   void (*chain_up) (GObject *) =
1101       ((GObjectClass *) empathy_roster_view_parent_class)->dispose;
1102
1103   /* Start by clearing the view so our internal hash tables are cleared from
1104    * objects being destroyed. */
1105   clear_view (self);
1106
1107   stop_flashing (self);
1108
1109   empathy_roster_view_set_live_search (self, NULL);
1110   g_clear_object (&self->priv->model);
1111
1112   if (self->priv->search_id != 0)
1113     {
1114       g_source_remove (self->priv->search_id);
1115       self->priv->search_id = 0;
1116     }
1117
1118   if (chain_up != NULL)
1119     chain_up (object);
1120 }
1121
1122 static void
1123 empathy_roster_view_finalize (GObject *object)
1124 {
1125   EmpathyRosterView *self = EMPATHY_ROSTER_VIEW (object);
1126   void (*chain_up) (GObject *) =
1127       ((GObjectClass *) empathy_roster_view_parent_class)->finalize;
1128
1129   g_hash_table_unref (self->priv->roster_contacts);
1130   g_hash_table_unref (self->priv->roster_groups);
1131   g_hash_table_unref (self->priv->displayed_contacts);
1132   g_queue_free_full (self->priv->events, event_free);
1133
1134   if (chain_up != NULL)
1135     chain_up (object);
1136 }
1137
1138 static void
1139 empathy_roster_view_row_activated (GtkListBox *box,
1140     GtkListBoxRow *row)
1141 {
1142   EmpathyRosterView *self = EMPATHY_ROSTER_VIEW (box);
1143   EmpathyRosterContact *contact;
1144   FolksIndividual *individual;
1145   GList *l;
1146
1147   if (!EMPATHY_IS_ROSTER_CONTACT (row))
1148     return;
1149
1150   contact = EMPATHY_ROSTER_CONTACT (row);
1151   individual = empathy_roster_contact_get_individual (contact);
1152
1153   /* Activate the oldest event associated with this contact, if any */
1154   for (l = g_queue_peek_tail_link (self->priv->events); l != NULL;
1155       l = g_list_previous (l))
1156     {
1157       Event *event = l->data;
1158
1159       if (event->individual == individual)
1160         {
1161           g_signal_emit (box, signals[SIG_EVENT_ACTIVATED], 0, individual,
1162               event->user_data);
1163           return;
1164         }
1165     }
1166
1167   g_signal_emit (box, signals[SIG_INDIVIDUAL_ACTIVATED], 0, individual);
1168 }
1169
1170 static void
1171 fire_popup_individual_menu (EmpathyRosterView *self,
1172     GtkListBoxRow *row,
1173     guint button,
1174     guint time)
1175 {
1176   EmpathyRosterContact *contact;
1177   FolksIndividual *individual;
1178   const gchar *active_group;
1179
1180   if (!EMPATHY_IS_ROSTER_CONTACT (row))
1181     return;
1182
1183   contact = EMPATHY_ROSTER_CONTACT (row);
1184   individual = empathy_roster_contact_get_individual (contact);
1185
1186   active_group = empathy_roster_contact_get_group (contact);
1187   g_signal_emit (self, signals[SIG_POPUP_INDIVIDUAL_MENU], 0,
1188       active_group, individual, button, time);
1189 }
1190
1191 static gboolean
1192 empathy_roster_view_button_press_event (GtkWidget *widget,
1193     GdkEventButton *event)
1194 {
1195   EmpathyRosterView *self = EMPATHY_ROSTER_VIEW (widget);
1196   gboolean (*chain_up) (GtkWidget *, GdkEventButton *) =
1197       ((GtkWidgetClass *) empathy_roster_view_parent_class)->button_press_event;
1198
1199   if (event->button == 3)
1200     {
1201       GtkListBoxRow *row;
1202
1203       row = gtk_list_box_get_row_at_y (GTK_LIST_BOX (self), event->y);
1204
1205       if (row != NULL)
1206         {
1207           gtk_list_box_select_row (GTK_LIST_BOX (self), row);
1208
1209           fire_popup_individual_menu (self, row, event->button, event->time);
1210         }
1211     }
1212
1213   return chain_up (widget, event);
1214 }
1215
1216 static gboolean
1217 empathy_roster_view_key_press_event (GtkWidget *widget,
1218     GdkEventKey *event)
1219 {
1220   EmpathyRosterView *self = EMPATHY_ROSTER_VIEW (widget);
1221   gboolean (*chain_up) (GtkWidget *, GdkEventKey *) =
1222       ((GtkWidgetClass *) empathy_roster_view_parent_class)->key_press_event;
1223
1224   if (event->keyval == GDK_KEY_Menu)
1225     {
1226       GtkListBoxRow *row;
1227
1228       row = gtk_list_box_get_selected_row (GTK_LIST_BOX (self));
1229
1230       if (row != NULL)
1231         fire_popup_individual_menu (self, row, 0, event->time);
1232     }
1233
1234   return chain_up (widget, event);
1235 }
1236
1237 /**
1238  * @out_row: (out) (allow-none)
1239  */
1240 FolksIndividual *
1241 empathy_roster_view_get_individual_at_y (EmpathyRosterView *self,
1242     gint y,
1243     GtkListBoxRow **out_row)
1244 {
1245   GtkListBoxRow *row;
1246
1247   row = gtk_list_box_get_row_at_y (GTK_LIST_BOX (self), y);
1248
1249   if (out_row != NULL)
1250     *out_row = row;
1251
1252   if (!EMPATHY_IS_ROSTER_CONTACT (row))
1253     return NULL;
1254
1255   return empathy_roster_contact_get_individual (EMPATHY_ROSTER_CONTACT (row));
1256 }
1257
1258 const gchar *
1259 empathy_roster_view_get_group_at_y (EmpathyRosterView *self,
1260     gint y)
1261 {
1262   GtkListBoxRow *row;
1263
1264   row = gtk_list_box_get_row_at_y (GTK_LIST_BOX (self), y);
1265
1266   if (EMPATHY_IS_ROSTER_CONTACT (row))
1267     return empathy_roster_contact_get_group (EMPATHY_ROSTER_CONTACT (row));
1268   else if (EMPATHY_IS_ROSTER_GROUP (row))
1269     return empathy_roster_group_get_name (EMPATHY_ROSTER_GROUP (row));
1270
1271   return NULL;
1272 }
1273
1274 static gboolean
1275 empathy_roster_view_query_tooltip (GtkWidget *widget,
1276     gint x,
1277     gint y,
1278     gboolean keyboard_mode,
1279     GtkTooltip *tooltip)
1280 {
1281   EmpathyRosterView *self = EMPATHY_ROSTER_VIEW (widget);
1282   FolksIndividual *individual;
1283   gboolean result;
1284   GtkListBoxRow *row;
1285
1286   individual = empathy_roster_view_get_individual_at_y (self, y, &row);
1287   if (individual == NULL)
1288     return FALSE;
1289
1290   g_signal_emit (self, signals[SIG_INDIVIDUAL_TOOLTIP], 0,
1291       individual, keyboard_mode, tooltip, &result);
1292
1293   if (result)
1294     {
1295       GtkAllocation allocation;
1296
1297       gtk_widget_get_allocation (GTK_WIDGET (row), &allocation);
1298       gtk_tooltip_set_tip_area (tooltip, (GdkRectangle *) &allocation);
1299     }
1300
1301   return result;
1302 }
1303
1304 static void
1305 empathy_roster_view_remove (GtkContainer *container,
1306     GtkWidget *widget)
1307 {
1308   EmpathyRosterView *self = EMPATHY_ROSTER_VIEW (container);
1309   void (*chain_up) (GtkContainer *, GtkWidget *) =
1310       ((GtkContainerClass *) empathy_roster_view_parent_class)->remove;
1311
1312   chain_up (container, widget);
1313
1314   if (EMPATHY_IS_ROSTER_CONTACT (widget))
1315     remove_from_displayed (self, (EmpathyRosterContact *) widget);
1316 }
1317
1318 static void
1319 empathy_roster_view_class_init (
1320     EmpathyRosterViewClass *klass)
1321 {
1322   GObjectClass *oclass = G_OBJECT_CLASS (klass);
1323   GtkListBoxClass *box_class = GTK_LIST_BOX_CLASS (klass);
1324   GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
1325   GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass);
1326   GParamSpec *spec;
1327
1328   oclass->get_property = empathy_roster_view_get_property;
1329   oclass->set_property = empathy_roster_view_set_property;
1330   oclass->constructed = empathy_roster_view_constructed;
1331   oclass->dispose = empathy_roster_view_dispose;
1332   oclass->finalize = empathy_roster_view_finalize;
1333
1334   widget_class->button_press_event = empathy_roster_view_button_press_event;
1335   widget_class->key_press_event = empathy_roster_view_key_press_event;
1336   widget_class->query_tooltip = empathy_roster_view_query_tooltip;
1337
1338   container_class->remove = empathy_roster_view_remove;
1339
1340   box_class->row_activated = empathy_roster_view_row_activated;
1341
1342   spec = g_param_spec_object ("model", "Model",
1343       "EmpathyRosterModel",
1344       EMPATHY_TYPE_ROSTER_MODEL,
1345       G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
1346   g_object_class_install_property (oclass, PROP_MODEL, spec);
1347
1348   spec = g_param_spec_boolean ("show-offline", "Show Offline",
1349       "Show offline contacts",
1350       FALSE,
1351       G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
1352   g_object_class_install_property (oclass, PROP_SHOW_OFFLINE, spec);
1353
1354   spec = g_param_spec_boolean ("show-groups", "Show Groups",
1355       "Show groups",
1356       FALSE,
1357       G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
1358   g_object_class_install_property (oclass, PROP_SHOW_GROUPS, spec);
1359
1360   spec = g_param_spec_boolean ("empty", "Empty",
1361       "Is the view currently empty?",
1362       FALSE,
1363       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
1364   g_object_class_install_property (oclass, PROP_EMPTY, spec);
1365
1366   signals[SIG_INDIVIDUAL_ACTIVATED] = g_signal_new ("individual-activated",
1367       G_OBJECT_CLASS_TYPE (klass),
1368       G_SIGNAL_RUN_LAST,
1369       0, NULL, NULL, NULL,
1370       G_TYPE_NONE,
1371       1, FOLKS_TYPE_INDIVIDUAL);
1372
1373   signals[SIG_POPUP_INDIVIDUAL_MENU] = g_signal_new ("popup-individual-menu",
1374       G_OBJECT_CLASS_TYPE (klass),
1375       G_SIGNAL_RUN_LAST,
1376       0, NULL, NULL, NULL,
1377       G_TYPE_NONE,
1378       4, G_TYPE_STRING, FOLKS_TYPE_INDIVIDUAL, G_TYPE_UINT,
1379           G_TYPE_UINT);
1380
1381   signals[SIG_EVENT_ACTIVATED] = g_signal_new ("event-activated",
1382       G_OBJECT_CLASS_TYPE (klass),
1383       G_SIGNAL_RUN_LAST,
1384       0, NULL, NULL, NULL,
1385       G_TYPE_NONE,
1386       2, FOLKS_TYPE_INDIVIDUAL, G_TYPE_POINTER);
1387
1388   signals[SIG_INDIVIDUAL_TOOLTIP] = g_signal_new ("individual-tooltip",
1389       G_OBJECT_CLASS_TYPE (klass),
1390       G_SIGNAL_RUN_LAST,
1391       0, g_signal_accumulator_true_handled, NULL, NULL,
1392       G_TYPE_BOOLEAN,
1393       3, FOLKS_TYPE_INDIVIDUAL, G_TYPE_BOOLEAN, GTK_TYPE_TOOLTIP);
1394
1395   g_type_class_add_private (klass, sizeof (EmpathyRosterViewPriv));
1396 }
1397
1398 static void
1399 empathy_roster_view_init (EmpathyRosterView *self)
1400 {
1401   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
1402       EMPATHY_TYPE_ROSTER_VIEW, EmpathyRosterViewPriv);
1403
1404   self->priv->roster_contacts = g_hash_table_new_full (NULL, NULL,
1405       NULL, (GDestroyNotify) g_hash_table_unref);
1406   self->priv->roster_groups = g_hash_table_new_full (g_str_hash, g_str_equal,
1407       g_free, NULL);
1408   self->priv->displayed_contacts = g_hash_table_new (NULL, NULL);
1409
1410   self->priv->events = g_queue_new ();
1411
1412   self->priv->empty = TRUE;
1413 }
1414
1415 GtkWidget *
1416 empathy_roster_view_new (EmpathyRosterModel *model)
1417 {
1418   g_return_val_if_fail (EMPATHY_IS_ROSTER_MODEL (model), NULL);
1419
1420   return g_object_new (EMPATHY_TYPE_ROSTER_VIEW,
1421       "model", model,
1422       NULL);
1423 }
1424
1425 void
1426 empathy_roster_view_show_offline (EmpathyRosterView *self,
1427     gboolean show)
1428 {
1429   if (self->priv->show_offline == show)
1430     return;
1431
1432   self->priv->show_offline = show;
1433   gtk_list_box_invalidate_filter (GTK_LIST_BOX (self));
1434
1435   g_object_notify (G_OBJECT (self), "show-offline");
1436 }
1437
1438 void
1439 empathy_roster_view_show_groups (EmpathyRosterView *self,
1440     gboolean show)
1441 {
1442   if (self->priv->show_groups == show)
1443     return;
1444
1445   self->priv->show_groups = show;
1446
1447   /* TODO: block sort/filter? */
1448   clear_view (self);
1449   populate_view (self);
1450
1451   g_object_notify (G_OBJECT (self), "show-groups");
1452 }
1453
1454 static void
1455 select_first_contact (EmpathyRosterView *self)
1456 {
1457   GList *children, *l;
1458
1459   children = gtk_container_get_children (GTK_CONTAINER (self));
1460   for (l = children; l != NULL; l = g_list_next (l))
1461     {
1462       GtkWidget *child = l->data;
1463
1464       if (!gtk_widget_get_child_visible (child))
1465         continue;
1466
1467       if (!EMPATHY_IS_ROSTER_CONTACT (child))
1468         continue;
1469
1470       gtk_list_box_select_row (GTK_LIST_BOX (self), GTK_LIST_BOX_ROW (child));
1471       break;
1472     }
1473
1474   g_list_free (children);
1475 }
1476
1477 static gboolean
1478 search_timeout_cb (EmpathyRosterView *self)
1479 {
1480   gtk_list_box_invalidate_filter (GTK_LIST_BOX (self));
1481
1482   select_first_contact (self);
1483
1484   self->priv->search_id = 0;
1485   return G_SOURCE_REMOVE;
1486 }
1487
1488 static void
1489 search_text_notify_cb (TpawLiveSearch *search,
1490     GParamSpec *pspec,
1491     EmpathyRosterView *self)
1492 {
1493   if (self->priv->search_id != 0)
1494     g_source_remove (self->priv->search_id);
1495
1496   self->priv->search_id = g_timeout_add (SEARCH_TIMEOUT,
1497       (GSourceFunc) search_timeout_cb, self);
1498 }
1499
1500 static void
1501 search_activate_cb (GtkWidget *search,
1502   EmpathyRosterView *self)
1503 {
1504   GtkListBox *box = GTK_LIST_BOX (self);
1505   GtkListBoxRow *row;
1506
1507   row = gtk_list_box_get_selected_row (box);
1508   if (row == NULL)
1509     return;
1510
1511   empathy_roster_view_row_activated (box, row);
1512 }
1513
1514 void
1515 empathy_roster_view_set_live_search (EmpathyRosterView *self,
1516     TpawLiveSearch *search)
1517 {
1518   if (self->priv->search != NULL)
1519     {
1520       g_signal_handlers_disconnect_by_func (self->priv->search,
1521           search_text_notify_cb, self);
1522       g_signal_handlers_disconnect_by_func (self->priv->search,
1523           search_activate_cb, self);
1524
1525       g_clear_object (&self->priv->search);
1526     }
1527
1528   if (search == NULL)
1529     return;
1530
1531   self->priv->search = g_object_ref (search);
1532
1533   g_signal_connect (self->priv->search, "notify::text",
1534       G_CALLBACK (search_text_notify_cb), self);
1535   g_signal_connect (self->priv->search, "activate",
1536       G_CALLBACK (search_activate_cb), self);
1537 }
1538
1539 gboolean
1540 empathy_roster_view_is_empty (EmpathyRosterView *self)
1541 {
1542   return self->priv->empty;
1543 }
1544
1545 gboolean
1546 empathy_roster_view_is_searching (EmpathyRosterView *self)
1547 {
1548   return (self->priv->search != NULL &&
1549       gtk_widget_get_visible (GTK_WIDGET (self->priv->search)));
1550 }
1551
1552 /* Don't use EmpathyEvent as I prefer to keep this object not too specific to
1553  * Empathy's internals. */
1554 guint
1555 empathy_roster_view_add_event (EmpathyRosterView *self,
1556     FolksIndividual *individual,
1557     const gchar *icon,
1558     gpointer user_data)
1559 {
1560   GHashTable *contacts;
1561
1562   contacts = g_hash_table_lookup (self->priv->roster_contacts, individual);
1563   if (contacts == NULL)
1564     return 0;
1565
1566   self->priv->last_event_id++;
1567
1568   g_queue_push_head (self->priv->events,
1569       event_new (self->priv->last_event_id, individual, icon, user_data));
1570
1571   start_flashing (self);
1572
1573   return self->priv->last_event_id;
1574 }
1575
1576 void
1577 empathy_roster_view_remove_event (EmpathyRosterView *self,
1578     guint event_id)
1579 {
1580   GList *l;
1581
1582   for (l = g_queue_peek_head_link (self->priv->events); l != NULL;
1583       l = g_list_next (l))
1584     {
1585       Event *event = l->data;
1586
1587       if (event->id == event_id)
1588         {
1589           remove_event (self, event);
1590           return;
1591         }
1592     }
1593 }
1594
1595 FolksIndividual *
1596 empathy_roster_view_get_selected_individual (EmpathyRosterView *self)
1597 {
1598   GtkListBoxRow *row;
1599
1600   row = gtk_list_box_get_selected_row (GTK_LIST_BOX (self));
1601
1602   if (!EMPATHY_IS_ROSTER_CONTACT (row))
1603     return NULL;
1604
1605   return empathy_roster_contact_get_individual (EMPATHY_ROSTER_CONTACT (row));
1606 }