?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Translation updated.
[empathy-mirror.git] / libempathy-gtk / gossip-contact-list-store.c
blob5c8393a1c5c3f8780624d34f7c4abfc69a774732
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2 /*
3 * Copyright (C) 2005-2007 Imendio AB
4 * Copyright (C) 2007 Collabora Ltd.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation; either version 2 of the
9 * License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public
17 * License along with this program; if not, write to the
18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 * Boston, MA 02111-1307, USA.
20 *
21 * Authors: Mikael Hallendal <micke@imendio.com>
22 * Martyn Russell <martyn@imendio.com>
23 * Xavier Claessens <xclaesse@gmail.com>
24 */
25
26 #include "config.h"
27
28 #include <string.h>
29
30 #include <glib.h>
31 #include <gtk/gtk.h>
32
33 #include <libempathy/gossip-debug.h>
34
35 #include "gossip-contact-list-store.h"
36 #include "gossip-contact-groups.h"
37 #include "gossip-ui-utils.h"
38
39 #define DEBUG_DOMAIN "ContactListStore"
40
41 /* Active users are those which have recently changed state
42 * (e.g. online, offline or from normal to a busy state).
43 */
44
45 /* Time user is shown as active */
46 #define ACTIVE_USER_SHOW_TIME 7000
47
48 /* Time after connecting which we wait before active users are enabled */
49 #define ACTIVE_USER_WAIT_TO_ENABLE_TIME 5000
50
51 #define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GOSSIP_TYPE_CONTACT_LIST_STORE, GossipContactListStorePriv))
52
53 struct _GossipContactListStorePriv {
54 EmpathyContactList *list;
55 gboolean show_offline;
56 gboolean show_avatars;
57 gboolean is_compact;
58 gboolean show_active;
59 GossipContactListStoreSort sort_criterium;
60 guint inhibit_active;
61
62 GossipContactGroupsFunc get_contact_groups;
63 gpointer get_contact_groups_data;
64 };
65
66 typedef struct {
67 GtkTreeIter iter;
68 const gchar *name;
69 gboolean found;
70 } FindGroup;
71
72 typedef struct {
73 GossipContact *contact;
74 gboolean found;
75 GList *iters;
76 } FindContact;
77
78 typedef struct {
79 GossipContactListStore *store;
80 GossipContact *contact;
81 gboolean remove;
82 } ShowActiveData;
83
84 static void gossip_contact_list_store_class_init (GossipContactListStoreClass *klass);
85 static void gossip_contact_list_store_init (GossipContactListStore *list);
86 static void contact_list_store_finalize (GObject *object);
87 static void contact_list_store_get_property (GObject *object,
88 guint param_id,
89 GValue *value,
90 GParamSpec *pspec);
91 static void contact_list_store_set_property (GObject *object,
92 guint param_id,
93 const GValue *value,
94 GParamSpec *pspec);
95 static void contact_list_store_setup (GossipContactListStore *store);
96 static gboolean contact_list_store_inibit_active_cb (GossipContactListStore *store);
97 static void contact_list_store_contact_added_cb (EmpathyContactList *list_iface,
98 GossipContact *contact,
99 GossipContactListStore *store);
100 static void contact_list_store_add_contact (GossipContactListStore *store,
101 GossipContact *contact);
102 static void contact_list_store_contact_removed_cb (EmpathyContactList *list_iface,
103 GossipContact *contact,
104 GossipContactListStore *store);
105 static void contact_list_store_remove_contact (GossipContactListStore *store,
106 GossipContact *contact);
107 static void contact_list_store_contact_update (GossipContactListStore *store,
108 GossipContact *contact);
109 static void contact_list_store_contact_groups_updated_cb (GossipContact *contact,
110 GParamSpec *param,
111 GossipContactListStore *store);
112 static void contact_list_store_contact_updated_cb (GossipContact *contact,
113 GParamSpec *param,
114 GossipContactListStore *store);
115 static void contact_list_store_contact_set_active (GossipContactListStore *store,
116 GossipContact *contact,
117 gboolean active,
118 gboolean set_changed);
119 static ShowActiveData * contact_list_store_contact_active_new (GossipContactListStore *store,
120 GossipContact *contact,
121 gboolean remove);
122 static void contact_list_store_contact_active_free (ShowActiveData *data);
123 static gboolean contact_list_store_contact_active_cb (ShowActiveData *data);
124 static gboolean contact_list_store_get_group_foreach (GtkTreeModel *model,
125 GtkTreePath *path,
126 GtkTreeIter *iter,
127 FindGroup *fg);
128 static void contact_list_store_get_group (GossipContactListStore *store,
129 const gchar *name,
130 GtkTreeIter *iter_group_to_set,
131 GtkTreeIter *iter_separator_to_set,
132 gboolean *created);
133 static gint contact_list_store_state_sort_func (GtkTreeModel *model,
134 GtkTreeIter *iter_a,
135 GtkTreeIter *iter_b,
136 gpointer user_data);
137 static gint contact_list_store_name_sort_func (GtkTreeModel *model,
138 GtkTreeIter *iter_a,
139 GtkTreeIter *iter_b,
140 gpointer user_data);
141 static gboolean contact_list_store_find_contact_foreach (GtkTreeModel *model,
142 GtkTreePath *path,
143 GtkTreeIter *iter,
144 FindContact *fc);
145 static GList * contact_list_store_find_contact (GossipContactListStore *store,
146 GossipContact *contact);
147 static gboolean contact_list_store_update_list_mode_foreach (GtkTreeModel *model,
148 GtkTreePath *path,
149 GtkTreeIter *iter,
150 GossipContactListStore *store);
151
152 enum {
153 PROP_0,
154 PROP_SHOW_OFFLINE,
155 PROP_SHOW_AVATARS,
156 PROP_IS_COMPACT,
157 PROP_SORT_CRITERIUM
158 };
159
160 GType
161 gossip_contact_list_store_sort_get_type (void)
162 {
163 static GType etype = 0;
164
165 if (etype == 0) {
166 static const GEnumValue values[] = {
167 { GOSSIP_CONTACT_LIST_STORE_SORT_NAME,
168 "GOSSIP_CONTACT_LIST_STORE_SORT_NAME",
169 "name" },
170 { GOSSIP_CONTACT_LIST_STORE_SORT_STATE,
171 "GOSSIP_CONTACT_LIST_STORE_SORT_STATE",
172 "state" },
173 { 0, NULL, NULL }
174 };
175
176 etype = g_enum_register_static ("GossipContactListStoreSort", values);
177 }
178
179 return etype;
180 }
181
182 G_DEFINE_TYPE (GossipContactListStore, gossip_contact_list_store, GTK_TYPE_TREE_STORE);
183
184 static void
185 gossip_contact_list_store_class_init (GossipContactListStoreClass *klass)
186 {
187 GObjectClass *object_class = G_OBJECT_CLASS (klass);
188
189 object_class->finalize = contact_list_store_finalize;
190 object_class->get_property = contact_list_store_get_property;
191 object_class->set_property = contact_list_store_set_property;
192
193 g_object_class_install_property (object_class,
194 PROP_SHOW_OFFLINE,
195 g_param_spec_boolean ("show-offline",
196 "Show Offline",
197 "Whether contact list should display "
198 "offline contacts",
199 FALSE,
200 G_PARAM_READWRITE));
201 g_object_class_install_property (object_class,
202 PROP_SHOW_AVATARS,
203 g_param_spec_boolean ("show-avatars",
204 "Show Avatars",
205 "Whether contact list should display "
206 "avatars for contacts",
207 TRUE,
208 G_PARAM_READWRITE));
209 g_object_class_install_property (object_class,
210 PROP_IS_COMPACT,
211 g_param_spec_boolean ("is-compact",
212 "Is Compact",
213 "Whether the contact list is in compact mode or not",
214 FALSE,
215 G_PARAM_READWRITE));
216
217 g_object_class_install_property (object_class,
218 PROP_SORT_CRITERIUM,
219 g_param_spec_enum ("sort-criterium",
220 "Sort citerium",
221 "The sort criterium to use for sorting the contact list",
222 GOSSIP_TYPE_CONTACT_LIST_STORE_SORT,
223 GOSSIP_CONTACT_LIST_STORE_SORT_NAME,
224 G_PARAM_READWRITE));
225
226 g_type_class_add_private (object_class, sizeof (GossipContactListStorePriv));
227 }
228
229 static void
230 gossip_contact_list_store_init (GossipContactListStore *store)
231 {
232 GossipContactListStorePriv *priv;
233
234 priv = GET_PRIV (store);
235
236 priv->inhibit_active = g_timeout_add (ACTIVE_USER_WAIT_TO_ENABLE_TIME,
237 (GSourceFunc) contact_list_store_inibit_active_cb,
238 store);
239 }
240
241 static void
242 contact_list_store_finalize (GObject *object)
243 {
244 GossipContactListStorePriv *priv;
245
246 priv = GET_PRIV (object);
247
248 /* FIXME: disconnect all signals on the list and contacts */
249
250 if (priv->list) {
251 g_object_unref (priv->list);
252 }
253
254 if (priv->inhibit_active) {
255 g_source_remove (priv->inhibit_active);
256 }
257
258 G_OBJECT_CLASS (gossip_contact_list_store_parent_class)->finalize (object);
259 }
260
261 static void
262 contact_list_store_get_property (GObject *object,
263 guint param_id,
264 GValue *value,
265 GParamSpec *pspec)
266 {
267 GossipContactListStorePriv *priv;
268
269 priv = GET_PRIV (object);
270
271 switch (param_id) {
272 case PROP_SHOW_OFFLINE:
273 g_value_set_boolean (value, priv->show_offline);
274 break;
275 case PROP_SHOW_AVATARS:
276 g_value_set_boolean (value, priv->show_avatars);
277 break;
278 case PROP_IS_COMPACT:
279 g_value_set_boolean (value, priv->is_compact);
280 break;
281 case PROP_SORT_CRITERIUM:
282 g_value_set_enum (value, priv->sort_criterium);
283 break;
284 default:
285 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
286 break;
287 };
288 }
289
290 static void
291 contact_list_store_set_property (GObject *object,
292 guint param_id,
293 const GValue *value,
294 GParamSpec *pspec)
295 {
296 GossipContactListStorePriv *priv;
297
298 priv = GET_PRIV (object);
299
300 switch (param_id) {
301 case PROP_SHOW_OFFLINE:
302 gossip_contact_list_store_set_show_offline (GOSSIP_CONTACT_LIST_STORE (object),
303 g_value_get_boolean (value));
304 break;
305 case PROP_SHOW_AVATARS:
306 gossip_contact_list_store_set_show_avatars (GOSSIP_CONTACT_LIST_STORE (object),
307 g_value_get_boolean (value));
308 break;
309 case PROP_IS_COMPACT:
310 gossip_contact_list_store_set_is_compact (GOSSIP_CONTACT_LIST_STORE (object),
311 g_value_get_boolean (value));
312 break;
313 case PROP_SORT_CRITERIUM:
314 gossip_contact_list_store_set_sort_criterium (GOSSIP_CONTACT_LIST_STORE (object),
315 g_value_get_enum (value));
316 break;
317 default:
318 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
319 break;
320 };
321 }
322
323 GossipContactListStore *
324 gossip_contact_list_store_new (EmpathyContactList *list_iface)
325 {
326 GossipContactListStore *store;
327 GossipContactListStorePriv *priv;
328 GList *contacts, *l;
329
330 g_return_val_if_fail (EMPATHY_IS_CONTACT_LIST (list_iface), NULL);
331
332 store = g_object_new (GOSSIP_TYPE_CONTACT_LIST_STORE, NULL);
333 priv = GET_PRIV (store);
334
335 contact_list_store_setup (store);
336 priv->list = g_object_ref (list_iface);
337
338 /* Signal connection. */
339 g_signal_connect (priv->list,
340 "contact-added",
341 G_CALLBACK (contact_list_store_contact_added_cb),
342 store);
343 g_signal_connect (priv->list,
344 "contact-removed",
345 G_CALLBACK (contact_list_store_contact_removed_cb),
346 store);
347
348 /* Add contacts already created. */
349 contacts = empathy_contact_list_get_members (priv->list);
350 for (l = contacts; l; l = l->next) {
351 GossipContact *contact;
352
353 contact = l->data;
354
355 contact_list_store_contact_added_cb (priv->list, contact, store);
356
357 g_object_unref (contact);
358 }
359 g_list_free (contacts);
360
361 return store;
362 }
363
364 EmpathyContactList *
365 gossip_contact_list_store_get_list_iface (GossipContactListStore *store)
366 {
367 GossipContactListStorePriv *priv;
368
369 g_return_val_if_fail (GOSSIP_IS_CONTACT_LIST_STORE (store), FALSE);
370
371 priv = GET_PRIV (store);
372
373 return priv->list;
374 }
375
376 gboolean
377 gossip_contact_list_store_get_show_offline (GossipContactListStore *store)
378 {
379 GossipContactListStorePriv *priv;
380
381 g_return_val_if_fail (GOSSIP_IS_CONTACT_LIST_STORE (store), FALSE);
382
383 priv = GET_PRIV (store);
384
385 return priv->show_offline;
386 }
387
388 void
389 gossip_contact_list_store_set_show_offline (GossipContactListStore *store,
390 gboolean show_offline)
391 {
392 GossipContactListStorePriv *priv;
393 GList *contacts, *l;
394 gboolean show_active;
395
396 g_return_if_fail (GOSSIP_IS_CONTACT_LIST_STORE (store));
397
398 priv = GET_PRIV (store);
399
400 priv->show_offline = show_offline;
401 show_active = priv->show_active;
402
403 /* Disable temporarily. */
404 priv->show_active = FALSE;
405
406 contacts = empathy_contact_list_get_members (priv->list);
407 for (l = contacts; l; l = l->next) {
408 GossipContact *contact;
409
410 contact = GOSSIP_CONTACT (l->data);
411
412 contact_list_store_contact_update (store, contact);
413
414 g_object_unref (contact);
415 }
416 g_list_free (contacts);
417
418 /* Restore to original setting. */
419 priv->show_active = show_active;
420 }
421
422 gboolean
423 gossip_contact_list_store_get_show_avatars (GossipContactListStore *store)
424 {
425 GossipContactListStorePriv *priv;
426
427 g_return_val_if_fail (GOSSIP_IS_CONTACT_LIST_STORE (store), TRUE);
428
429 priv = GET_PRIV (store);
430
431 return priv->show_avatars;
432 }
433
434 void
435 gossip_contact_list_store_set_show_avatars (GossipContactListStore *store,
436 gboolean show_avatars)
437 {
438 GossipContactListStorePriv *priv;
439 GtkTreeModel *model;
440
441 g_return_if_fail (GOSSIP_IS_CONTACT_LIST_STORE (store));
442
443 priv = GET_PRIV (store);
444
445 priv->show_avatars = show_avatars;
446
447 model = GTK_TREE_MODEL (store);
448
449 gtk_tree_model_foreach (model,
450 (GtkTreeModelForeachFunc)
451 contact_list_store_update_list_mode_foreach,
452 store);
453 }
454
455 gboolean
456 gossip_contact_list_store_get_is_compact (GossipContactListStore *store)
457 {
458 GossipContactListStorePriv *priv;
459
460 g_return_val_if_fail (GOSSIP_IS_CONTACT_LIST_STORE (store), TRUE);
461
462 priv = GET_PRIV (store);
463
464 return priv->is_compact;
465 }
466
467 void
468 gossip_contact_list_store_set_is_compact (GossipContactListStore *store,
469 gboolean is_compact)
470 {
471 GossipContactListStorePriv *priv;
472 GtkTreeModel *model;
473
474 g_return_if_fail (GOSSIP_IS_CONTACT_LIST_STORE (store));
475
476 priv = GET_PRIV (store);
477
478 priv->is_compact = is_compact;
479
480 model = GTK_TREE_MODEL (store);
481
482 gtk_tree_model_foreach (model,
483 (GtkTreeModelForeachFunc)
484 contact_list_store_update_list_mode_foreach,
485 store);
486 }
487
488 GossipContactListStoreSort
489 gossip_contact_list_store_get_sort_criterium (GossipContactListStore *store)
490 {
491 GossipContactListStorePriv *priv;
492
493 g_return_val_if_fail (GOSSIP_IS_CONTACT_LIST_STORE (store), 0);
494
495 priv = GET_PRIV (store);
496
497 return priv->sort_criterium;
498 }
499
500 void
501 gossip_contact_list_store_set_sort_criterium (GossipContactListStore *store,
502 GossipContactListStoreSort sort_criterium)
503 {
504 GossipContactListStorePriv *priv;
505
506 g_return_if_fail (GOSSIP_IS_CONTACT_LIST_STORE (store));
507
508 priv = GET_PRIV (store);
509
510 priv->sort_criterium = sort_criterium;
511
512 switch (sort_criterium) {
513 case GOSSIP_CONTACT_LIST_STORE_SORT_STATE:
514 gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
515 COL_STATUS,
516 GTK_SORT_ASCENDING);
517 break;
518
519 case GOSSIP_CONTACT_LIST_STORE_SORT_NAME:
520 gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
521 COL_NAME,
522 GTK_SORT_ASCENDING);
523 break;
524 }
525 }
526
527 gboolean
528 gossip_contact_list_store_row_separator_func (GtkTreeModel *model,
529 GtkTreeIter *iter,
530 gpointer data)
531 {
532 gboolean is_separator = FALSE;
533
534 g_return_val_if_fail (GTK_IS_TREE_MODEL (model), FALSE);
535
536 gtk_tree_model_get (model, iter,
537 COL_IS_SEPARATOR, &is_separator,
538 -1);
539
540 return is_separator;
541 }
542
543 gchar *
544 gossip_contact_list_store_get_parent_group (GtkTreeModel *model,
545 GtkTreePath *path,
546 gboolean *path_is_group)
547 {
548 GtkTreeIter parent_iter, iter;
549 gchar *name = NULL;
550 gboolean is_group;
551
552 g_return_val_if_fail (GTK_IS_TREE_MODEL (model), NULL);
553
554 if (path_is_group) {
555 *path_is_group = FALSE;
556 }
557
558 if (!gtk_tree_model_get_iter (model, &iter, path)) {
559 return NULL;
560 }
561
562 gtk_tree_model_get (model, &iter,
563 COL_IS_GROUP, &is_group,
564 COL_NAME, &name,
565 -1);
566
567 if (!is_group) {
568 g_free (name);
569 name = NULL;
570
571 if (!gtk_tree_model_iter_parent (model, &parent_iter, &iter)) {
572 return NULL;
573 }
574
575 iter = parent_iter;
576
577 gtk_tree_model_get (model, &iter,
578 COL_IS_GROUP, &is_group,
579 COL_NAME, &name,
580 -1);
581 if (!is_group) {
582 g_free (name);
583 return NULL;
584 }
585 }
586
587 if (path_is_group) {
588 *path_is_group = TRUE;
589 }
590
591 return name;
592 }
593
594 gboolean
595 gossip_contact_list_store_search_equal_func (GtkTreeModel *model,
596 gint column,
597 const gchar *key,
598 GtkTreeIter *iter,
599 gpointer search_data)
600 {
601 gchar *name, *name_folded;
602 gchar *key_folded;
603 gboolean ret;
604
605 g_return_val_if_fail (GTK_IS_TREE_MODEL (model), FALSE);
606
607 if (!key) {
608 return FALSE;
609 }
610
611 gtk_tree_model_get (model, iter, COL_NAME, &name, -1);
612
613 if (!name) {
614 return FALSE;
615 }
616
617 name_folded = g_utf8_casefold (name, -1);
618 key_folded = g_utf8_casefold (key, -1);
619
620 if (name_folded && key_folded &&
621 strstr (name_folded, key_folded)) {
622 ret = FALSE;
623 } else {
624 ret = TRUE;
625 }
626
627 g_free (name);
628 g_free (name_folded);
629 g_free (key_folded);
630
631 return ret;
632 }
633
634 void
635 gossip_contact_list_store_set_contact_groups_func (GossipContactListStore *store,
636 GossipContactGroupsFunc func,
637 gpointer user_data)
638 {
639 GossipContactListStorePriv *priv;
640 GList *contacts, *l;
641
642 g_return_if_fail (GOSSIP_IS_CONTACT_LIST_STORE (store));
643
644 priv = GET_PRIV (store);
645
646 if (func) {
647 priv->get_contact_groups = func;
648 priv->get_contact_groups_data = user_data;
649 } else {
650 priv->get_contact_groups = NULL;
651 priv->get_contact_groups_data = NULL;
652 }
653
654 /* If we set a custom function to get contacts groups we have to
655 * disconnect our default notify::groups signal and wait for the user
656 * to call himself gossip_contact_list_store_update_contact_groups ()
657 * when needed. If func is NULL we come back to default.
658 */
659 contacts = empathy_contact_list_get_members (priv->list);
660 for (l = contacts; l; l = l->next) {
661 GossipContact *contact;
662
663 contact = l->data;
664
665 if (func) {
666 g_signal_handlers_disconnect_by_func (contact,
667 G_CALLBACK (contact_list_store_contact_groups_updated_cb),
668 store);
669 } else {
670 g_signal_connect (contact, "notify::groups",
671 G_CALLBACK (contact_list_store_contact_groups_updated_cb),
672 store);
673 }
674
675 gossip_contact_list_store_update_contact_groups (store, contact);
676
677 g_object_unref (contact);
678 }
679 g_list_free (contacts);
680 }
681
682 void
683 gossip_contact_list_store_update_contact_groups (GossipContactListStore *store,
684 GossipContact *contact)
685 {
686 GossipContactListStorePriv *priv;
687 gboolean show_active;
688
689 g_return_if_fail (GOSSIP_IS_CONTACT_LIST_STORE (store));
690 g_return_if_fail (GOSSIP_IS_CONTACT (contact));
691
692 priv = GET_PRIV (store);
693
694 gossip_debug (DEBUG_DOMAIN, "Contact:'%s' updating groups",
695 gossip_contact_get_name (contact));
696
697 /* We do this to make sure the groups are correct, if not, we
698 * would have to check the groups already set up for each
699 * contact and then see what has been updated.
700 */
701 show_active = priv->show_active;
702 priv->show_active = FALSE;
703 contact_list_store_remove_contact (store, contact);
704 contact_list_store_add_contact (store, contact);
705 priv->show_active = show_active;
706 }
707
708 static void
709 contact_list_store_setup (GossipContactListStore *store)
710 {
711 GossipContactListStorePriv *priv;
712 GType types[] = {G_TYPE_STRING, /* Status icon-name */
713 GDK_TYPE_PIXBUF, /* Avatar pixbuf */
714 G_TYPE_BOOLEAN, /* Avatar pixbuf visible */
715 G_TYPE_STRING, /* Name */
716 G_TYPE_STRING, /* Status string */
717 G_TYPE_BOOLEAN, /* Show status */
718 GOSSIP_TYPE_CONTACT, /* Contact type */
719 G_TYPE_BOOLEAN, /* Is group */
720 G_TYPE_BOOLEAN, /* Is active */
721 G_TYPE_BOOLEAN, /* Is online */
722 G_TYPE_BOOLEAN}; /* Is separator */
723
724 priv = GET_PRIV (store);
725
726 gtk_tree_store_set_column_types (GTK_TREE_STORE (store), COL_COUNT, types);
727
728 /* Set up sorting */
729 gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store),
730 COL_NAME,
731 contact_list_store_name_sort_func,
732 store, NULL);
733 gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store),
734 COL_STATUS,
735 contact_list_store_state_sort_func,
736 store, NULL);
737
738 priv->sort_criterium = GOSSIP_CONTACT_LIST_STORE_SORT_NAME;
739 gossip_contact_list_store_set_sort_criterium (store, priv->sort_criterium);
740 }
741
742 static gboolean
743 contact_list_store_inibit_active_cb (GossipContactListStore *store)
744 {
745 GossipContactListStorePriv *priv;
746
747 priv = GET_PRIV (store);
748
749 priv->show_active = TRUE;
750 priv->inhibit_active = 0;
751
752 return FALSE;
753 }
754
755 static void
756 contact_list_store_contact_added_cb (EmpathyContactList *list_iface,
757 GossipContact *contact,
758 GossipContactListStore *store)
759 {
760 GossipContactListStorePriv *priv;
761
762 priv = GET_PRIV (store);
763
764 gossip_debug (DEBUG_DOMAIN,
765 "Contact:'%s' added",
766 gossip_contact_get_name (contact));
767
768 if (!priv->get_contact_groups) {
769 g_signal_connect (contact, "notify::groups",
770 G_CALLBACK (contact_list_store_contact_groups_updated_cb),
771 store);
772 }
773 g_signal_connect (contact, "notify::presence",
774 G_CALLBACK (contact_list_store_contact_updated_cb),
775 store);
776 g_signal_connect (contact, "notify::name",
777 G_CALLBACK (contact_list_store_contact_updated_cb),
778 store);
779 g_signal_connect (contact, "notify::avatar",
780 G_CALLBACK (contact_list_store_contact_updated_cb),
781 store);
782 g_signal_connect (contact, "notify::type",
783 G_CALLBACK (contact_list_store_contact_updated_cb),
784 store);
785
786 contact_list_store_add_contact (store, contact);
787 }
788
789 static void
790 contact_list_store_add_contact (GossipContactListStore *store,
791 GossipContact *contact)
792 {
793 GossipContactListStorePriv *priv;
794 GtkTreeIter iter;
795 GList *groups, *l;
796
797 priv = GET_PRIV (store);
798
799 if (!priv->show_offline && !gossip_contact_is_online (contact)) {
800 return;
801 }
802
803 /* If no groups just add it at the top level. */
804 if (priv->get_contact_groups) {
805 groups = priv->get_contact_groups (contact,
806 priv->get_contact_groups_data);
807 } else {
808 groups = gossip_contact_get_groups (contact);
809 }
810
811 if (!groups) {
812 gtk_tree_store_append (GTK_TREE_STORE (store), &iter, NULL);
813 gtk_tree_store_set (GTK_TREE_STORE (store), &iter,
814 COL_NAME, gossip_contact_get_name (contact),
815 COL_CONTACT, contact,
816 COL_IS_GROUP, FALSE,
817 COL_IS_SEPARATOR, FALSE,
818 -1);
819 }
820
821 /* Else add to each group. */
822 for (l = groups; l; l = l->next) {
823 GtkTreeIter iter_group;
824 const gchar *name;
825
826 name = l->data;
827 if (!name) {
828 continue;
829 }
830
831 contact_list_store_get_group (store, name, &iter_group, NULL, NULL);
832
833 gtk_tree_store_insert_after (GTK_TREE_STORE (store), &iter,
834 &iter_group, NULL);
835 gtk_tree_store_set (GTK_TREE_STORE (store), &iter,
836 COL_NAME, gossip_contact_get_name (contact),
837 COL_CONTACT, contact,
838 COL_IS_GROUP, FALSE,
839 COL_IS_SEPARATOR, FALSE,
840 -1);
841 }
842
843 contact_list_store_contact_update (store, contact);
844 }
845
846 static void
847 contact_list_store_contact_removed_cb (EmpathyContactList *list_iface,
848 GossipContact *contact,
849 GossipContactListStore *store)
850 {
851 gossip_debug (DEBUG_DOMAIN, "Contact:'%s' removed",
852 gossip_contact_get_name (contact));
853
854 /* Disconnect signals */
855 g_signal_handlers_disconnect_by_func (contact,
856 G_CALLBACK (contact_list_store_contact_groups_updated_cb),
857 store);
858 g_signal_handlers_disconnect_by_func (contact,
859 G_CALLBACK (contact_list_store_contact_updated_cb),
860 store);
861
862 contact_list_store_remove_contact (store, contact);
863 }
864
865 static void
866 contact_list_store_remove_contact (GossipContactListStore *store,
867 GossipContact *contact)
868 {
869 GossipContactListStorePriv *priv;
870 GtkTreeModel *model;
871 GList *iters, *l;
872
873 priv = GET_PRIV (store);
874
875 iters = contact_list_store_find_contact (store, contact);
876 if (!iters) {
877 return;
878 }
879
880 /* Clean up model */
881 model = GTK_TREE_MODEL (store);
882
883 for (l = iters; l; l = l->next) {
884 GtkTreeIter parent;
885
886 /* NOTE: it is only <= 2 here because we have
887 * separators after the group name, otherwise it
888 * should be 1.
889 */
890 if (gtk_tree_model_iter_parent (model, &parent, l->data) &&
891 gtk_tree_model_iter_n_children (model, &parent) <= 2) {
892 gtk_tree_store_remove (GTK_TREE_STORE (store), &parent);
893 } else {
894 gtk_tree_store_remove (GTK_TREE_STORE (store), l->data);
895 }
896 }
897
898 g_list_foreach (iters, (GFunc) gtk_tree_iter_free, NULL);
899 g_list_free (iters);
900 }
901
902 static void
903 contact_list_store_contact_update (GossipContactListStore *store,
904 GossipContact *contact)
905 {
906 GossipContactListStorePriv *priv;
907 ShowActiveData *data;
908 GtkTreeModel *model;
909 GList *iters, *l;
910 gboolean in_list;
911 gboolean should_be_in_list;
912 gboolean was_online = TRUE;
913 gboolean now_online = FALSE;
914 gboolean set_model = FALSE;
915 gboolean do_remove = FALSE;
916 gboolean do_set_active = FALSE;
917 gboolean do_set_refresh = FALSE;
918 GdkPixbuf *pixbuf_avatar;
919
920 priv = GET_PRIV (store);
921
922 model = GTK_TREE_MODEL (store);
923
924 iters = contact_list_store_find_contact (store, contact);
925 if (!iters) {
926 in_list = FALSE;
927 } else {
928 in_list = TRUE;
929 }
930
931 /* Get online state now. */
932 now_online = gossip_contact_is_online (contact);
933
934 if (priv->show_offline || now_online) {
935 should_be_in_list = TRUE;
936 } else {
937 should_be_in_list = FALSE;
938 }
939
940 if (!in_list && !should_be_in_list) {
941 /* Nothing to do. */
942 gossip_debug (DEBUG_DOMAIN,
943 "Contact:'%s' in list:NO, should be:NO",
944 gossip_contact_get_name (contact));
945
946 g_list_foreach (iters, (GFunc) gtk_tree_iter_free, NULL);
947 g_list_free (iters);
948 return;
949 }
950 else if (in_list && !should_be_in_list) {
951 gossip_debug (DEBUG_DOMAIN,
952 "Contact:'%s' in list:YES, should be:NO",
953 gossip_contact_get_name (contact));
954
955 if (priv->show_active) {
956 do_remove = TRUE;
957 do_set_active = TRUE;
958 do_set_refresh = TRUE;
959
960 set_model = TRUE;
961 gossip_debug (DEBUG_DOMAIN, "Remove item (after timeout)");
962 } else {
963 gossip_debug (DEBUG_DOMAIN, "Remove item (now)!");
964 contact_list_store_remove_contact (store, contact);
965 }
966 }
967 else if (!in_list && should_be_in_list) {
968 gossip_debug (DEBUG_DOMAIN,
969 "Contact:'%s' in list:NO, should be:YES",
970 gossip_contact_get_name (contact));
971
972 contact_list_store_add_contact (store, contact);
973
974 if (priv->show_active) {
975 do_set_active = TRUE;
976
977 gossip_debug (DEBUG_DOMAIN, "Set active (contact added)");
978 }
979 } else {
980 gossip_debug (DEBUG_DOMAIN,
981 "Contact:'%s' in list:YES, should be:YES",
982 gossip_contact_get_name (contact));
983
984 /* Get online state before. */
985 if (iters && g_list_length (iters) > 0) {
986 gtk_tree_model_get (model, iters->data,
987 COL_IS_ONLINE, &was_online,
988 -1);
989 }
990
991 /* Is this really an update or an online/offline. */
992 if (priv->show_active) {
993 if (was_online != now_online) {
994 do_set_active = TRUE;
995 do_set_refresh = TRUE;
996
997 gossip_debug (DEBUG_DOMAIN, "Set active (contact updated %s)",
998 was_online ? "online -> offline" :
999 "offline -> online");
1000 } else {
1001 /* Was TRUE for presence updates. */
1002 /* do_set_active = FALSE; */
1003 do_set_refresh = TRUE;
1004
1005 gossip_debug (DEBUG_DOMAIN, "Set active (contact updated)");
1006 }
1007 }
1008
1009 set_model = TRUE;
1010 }
1011
1012 pixbuf_avatar = gossip_pixbuf_avatar_from_contact_scaled (contact, 32, 32);
1013 for (l = iters; l && set_model; l = l->next) {
1014 gtk_tree_store_set (GTK_TREE_STORE (store), l->data,
1015 COL_ICON_STATUS, gossip_icon_name_for_contact (contact),
1016 COL_PIXBUF_AVATAR, pixbuf_avatar,
1017 COL_PIXBUF_AVATAR_VISIBLE, priv->show_avatars,
1018 COL_NAME, gossip_contact_get_name (contact),
1019 COL_STATUS, gossip_contact_get_status (contact),
1020 COL_STATUS_VISIBLE, !priv->is_compact,
1021 COL_IS_GROUP, FALSE,
1022 COL_IS_ONLINE, now_online,
1023 COL_IS_SEPARATOR, FALSE,
1024 -1);
1025 }
1026
1027 if (pixbuf_avatar) {
1028 g_object_unref (pixbuf_avatar);
1029 }
1030
1031 if (priv->show_active && do_set_active) {
1032 contact_list_store_contact_set_active (store, contact, do_set_active, do_set_refresh);
1033
1034 if (do_set_active) {
1035 data = contact_list_store_contact_active_new (store, contact, do_remove);
1036 g_timeout_add (ACTIVE_USER_SHOW_TIME,
1037 (GSourceFunc) contact_list_store_contact_active_cb,
1038 data);
1039 }
1040 }
1041
1042 /* FIXME: when someone goes online then offline quickly, the
1043 * first timeout sets the user to be inactive and the second
1044 * timeout removes the user from the contact list, really we
1045 * should remove the first timeout.
1046 */
1047 g_list_foreach (iters, (GFunc) gtk_tree_iter_free, NULL);
1048 g_list_free (iters);
1049 }
1050
1051 static void
1052 contact_list_store_contact_groups_updated_cb (GossipContact *contact,
1053 GParamSpec *param,
1054 GossipContactListStore *store)
1055 {
1056 gossip_contact_list_store_update_contact_groups (store, contact);
1057 }
1058
1059 static void
1060 contact_list_store_contact_updated_cb (GossipContact *contact,
1061 GParamSpec *param,
1062 GossipContactListStore *store)
1063 {
1064 gossip_debug (DEBUG_DOMAIN,
1065 "Contact:'%s' updated, checking roster is in sync...",
1066 gossip_contact_get_name (contact));
1067
1068 contact_list_store_contact_update (store, contact);
1069 }
1070
1071 static void
1072 contact_list_store_contact_set_active (GossipContactListStore *store,
1073 GossipContact *contact,
1074 gboolean active,
1075 gboolean set_changed)
1076 {
1077 GossipContactListStorePriv *priv;
1078 GtkTreeModel *model;
1079 GList *iters, *l;
1080
1081 priv = GET_PRIV (store);
1082 model = GTK_TREE_MODEL (store);
1083
1084 iters = contact_list_store_find_contact (store, contact);
1085 for (l = iters; l; l = l->next) {
1086 GtkTreePath *path;
1087
1088 gtk_tree_store_set (GTK_TREE_STORE (store), l->data,
1089 COL_IS_ACTIVE, active,
1090 -1);
1091
1092 gossip_debug (DEBUG_DOMAIN, "Set item %s", active ? "active" : "inactive");
1093
1094 if (set_changed) {
1095 path = gtk_tree_model_get_path (model, l->data);
1096 gtk_tree_model_row_changed (model, path, l->data);
1097 gtk_tree_path_free (path);
1098 }
1099 }
1100
1101 g_list_foreach (iters, (GFunc) gtk_tree_iter_free, NULL);
1102 g_list_free (iters);
1103
1104 }
1105
1106 static ShowActiveData *
1107 contact_list_store_contact_active_new (GossipContactListStore *store,
1108 GossipContact *contact,
1109 gboolean remove)
1110 {
1111 ShowActiveData *data;
1112
1113 gossip_debug (DEBUG_DOMAIN,
1114 "Contact:'%s' now active, and %s be removed",
1115 gossip_contact_get_name (contact),
1116 remove ? "WILL" : "WILL NOT");
1117
1118 data = g_slice_new0 (ShowActiveData);
1119
1120 data->store = g_object_ref (store);
1121 data->contact = g_object_ref (contact);
1122 data->remove = remove;
1123
1124 return data;
1125 }
1126
1127 static void
1128 contact_list_store_contact_active_free (ShowActiveData *data)
1129 {
1130 g_object_unref (data->contact);
1131 g_object_unref (data->store);
1132
1133 g_slice_free (ShowActiveData, data);
1134 }
1135
1136 static gboolean
1137 contact_list_store_contact_active_cb (ShowActiveData *data)
1138 {
1139 GossipContactListStorePriv *priv;
1140
1141 priv = GET_PRIV (data->store);
1142
1143 if (data->remove &&
1144 !priv->show_offline &&
1145 !gossip_contact_is_online (data->contact)) {
1146 gossip_debug (DEBUG_DOMAIN,
1147 "Contact:'%s' active timeout, removing item",
1148 gossip_contact_get_name (data->contact));
1149 contact_list_store_remove_contact (data->store, data->contact);
1150 }
1151
1152 gossip_debug (DEBUG_DOMAIN,
1153 "Contact:'%s' no longer active",
1154 gossip_contact_get_name (data->contact));
1155
1156 contact_list_store_contact_set_active (data->store,
1157 data->contact,
1158 FALSE,
1159 TRUE);
1160
1161 contact_list_store_contact_active_free (data);
1162
1163 return FALSE;
1164 }
1165
1166 static gboolean
1167 contact_list_store_get_group_foreach (GtkTreeModel *model,
1168 GtkTreePath *path,
1169 GtkTreeIter *iter,
1170 FindGroup *fg)
1171 {
1172 gchar *str;
1173 gboolean is_group;
1174
1175 /* Groups are only at the top level. */
1176 if (gtk_tree_path_get_depth (path) != 1) {
1177 return FALSE;
1178 }
1179
1180 gtk_tree_model_get (model, iter,
1181 COL_NAME, &str,
1182 COL_IS_GROUP, &is_group,
1183 -1);
1184
1185 if (is_group && strcmp (str, fg->name) == 0) {
1186 fg->found = TRUE;
1187 fg->iter = *iter;
1188 }
1189
1190 g_free (str);
1191
1192 return fg->found;
1193 }
1194
1195 static void
1196 contact_list_store_get_group (GossipContactListStore *store,
1197 const gchar *name,
1198 GtkTreeIter *iter_group_to_set,
1199 GtkTreeIter *iter_separator_to_set,
1200 gboolean *created)
1201 {
1202 GossipContactListStorePriv *priv;
1203 GtkTreeModel *model;
1204 GtkTreeIter iter_group;
1205 GtkTreeIter iter_separator;
1206 FindGroup fg;
1207
1208 priv = GET_PRIV (store);
1209
1210 memset (&fg, 0, sizeof (fg));
1211
1212 fg.name = name;
1213
1214 model = GTK_TREE_MODEL (store);
1215 gtk_tree_model_foreach (model,
1216 (GtkTreeModelForeachFunc) contact_list_store_get_group_foreach,
1217 &fg);
1218
1219 if (!fg.found) {
1220 if (created) {
1221 *created = TRUE;
1222 }
1223
1224 gtk_tree_store_append (GTK_TREE_STORE (store), &iter_group, NULL);
1225 gtk_tree_store_set (GTK_TREE_STORE (store), &iter_group,
1226 COL_ICON_STATUS, NULL,
1227 COL_NAME, name,
1228 COL_IS_GROUP, TRUE,
1229 COL_IS_ACTIVE, FALSE,
1230 COL_IS_SEPARATOR, FALSE,
1231 -1);
1232
1233 if (iter_group_to_set) {
1234 *iter_group_to_set = iter_group;
1235 }
1236
1237 gtk_tree_store_append (GTK_TREE_STORE (store),
1238 &iter_separator,
1239 &iter_group);
1240 gtk_tree_store_set (GTK_TREE_STORE (store), &iter_separator,
1241 COL_IS_SEPARATOR, TRUE,
1242 -1);
1243
1244 if (iter_separator_to_set) {
1245 *iter_separator_to_set = iter_separator;
1246 }
1247 } else {
1248 if (created) {
1249 *created = FALSE;
1250 }
1251
1252 if (iter_group_to_set) {
1253 *iter_group_to_set = fg.iter;
1254 }
1255
1256 iter_separator = fg.iter;
1257
1258 if (gtk_tree_model_iter_next (model, &iter_separator)) {
1259 gboolean is_separator;
1260
1261 gtk_tree_model_get (model, &iter_separator,
1262 COL_IS_SEPARATOR, &is_separator,
1263 -1);
1264
1265 if (is_separator && iter_separator_to_set) {
1266 *iter_separator_to_set = iter_separator;
1267 }
1268 }
1269 }
1270 }
1271
1272 static gint
1273 contact_list_store_state_sort_func (GtkTreeModel *model,
1274 GtkTreeIter *iter_a,
1275 GtkTreeIter *iter_b,
1276 gpointer user_data)
1277 {
1278 gint ret_val = 0;
1279 gchar *name_a, *name_b;
1280 gboolean is_separator_a, is_separator_b;
1281 GossipContact *contact_a, *contact_b;
1282 GossipPresence *presence_a, *presence_b;
1283 McPresence state_a, state_b;
1284
1285 gtk_tree_model_get (model, iter_a,
1286 COL_NAME, &name_a,
1287 COL_CONTACT, &contact_a,
1288 COL_IS_SEPARATOR, &is_separator_a,
1289 -1);
1290 gtk_tree_model_get (model, iter_b,
1291 COL_NAME, &name_b,
1292 COL_CONTACT, &contact_b,
1293 COL_IS_SEPARATOR, &is_separator_b,
1294 -1);
1295
1296 /* Separator or group? */
1297 if (is_separator_a || is_separator_b) {
1298 if (is_separator_a) {
1299 ret_val = -1;
1300 } else if (is_separator_b) {
1301 ret_val = 1;
1302 }
1303 } else if (!contact_a && contact_b) {
1304 ret_val = 1;
1305 } else if (contact_a && !contact_b) {
1306 ret_val = -1;
1307 } else if (!contact_a && !contact_b) {
1308 /* Handle groups */
1309 ret_val = g_utf8_collate (name_a, name_b);
1310 }
1311
1312 if (ret_val) {
1313 goto free_and_out;
1314 }
1315
1316 /* If we managed to get this far, we can start looking at
1317 * the presences.
1318 */
1319 presence_a = gossip_contact_get_presence (GOSSIP_CONTACT (contact_a));
1320 presence_b = gossip_contact_get_presence (GOSSIP_CONTACT (contact_b));
1321
1322 if (!presence_a && presence_b) {
1323 ret_val = 1;
1324 } else if (presence_a && !presence_b) {
1325 ret_val = -1;
1326 } else if (!presence_a && !presence_b) {
1327 /* Both offline, sort by name */
1328 ret_val = g_utf8_collate (name_a, name_b);
1329 } else {
1330 state_a = gossip_presence_get_state (presence_a);
1331 state_b = gossip_presence_get_state (presence_b);
1332
1333 if (state_a < state_b) {
1334 ret_val = -1;
1335 } else if (state_a > state_b) {
1336 ret_val = 1;
1337 } else {
1338 /* Fallback: compare by name */
1339 ret_val = g_utf8_collate (name_a, name_b);
1340 }
1341 }
1342
1343 free_and_out:
1344 g_free (name_a);
1345 g_free (name_b);
1346
1347 if (contact_a) {
1348 g_object_unref (contact_a);
1349 }
1350
1351 if (contact_b) {
1352 g_object_unref (contact_b);
1353 }
1354
1355 return ret_val;
1356 }
1357
1358 static gint
1359 contact_list_store_name_sort_func (GtkTreeModel *model,
1360 GtkTreeIter *iter_a,
1361 GtkTreeIter *iter_b,
1362 gpointer user_data)
1363 {
1364 gchar *name_a, *name_b;
1365 GossipContact *contact_a, *contact_b;
1366 gboolean is_separator_a, is_separator_b;
1367 gint ret_val;
1368
1369 gtk_tree_model_get (model, iter_a,
1370 COL_NAME, &name_a,
1371 COL_CONTACT, &contact_a,
1372 COL_IS_SEPARATOR, &is_separator_a,
1373 -1);
1374 gtk_tree_model_get (model, iter_b,
1375 COL_NAME, &name_b,
1376 COL_CONTACT, &contact_b,
1377 COL_IS_SEPARATOR, &is_separator_b,
1378 -1);
1379
1380 /* If contact is NULL it means it's a group. */
1381
1382 if (is_separator_a || is_separator_b) {
1383 if (is_separator_a) {
1384 ret_val = -1;
1385 } else if (is_separator_b) {
1386 ret_val = 1;
1387 }
1388 } else if (!contact_a && contact_b) {
1389 ret_val = 1;
1390 } else if (contact_a && !contact_b) {
1391 ret_val = -1;
1392 } else {
1393 ret_val = g_utf8_collate (name_a, name_b);
1394 }
1395
1396 g_free (name_a);
1397 g_free (name_b);
1398
1399 if (contact_a) {
1400 g_object_unref (contact_a);
1401 }
1402
1403 if (contact_b) {
1404 g_object_unref (contact_b);
1405 }
1406
1407 return ret_val;
1408 }
1409
1410 static gboolean
1411 contact_list_store_find_contact_foreach (GtkTreeModel *model,
1412 GtkTreePath *path,
1413 GtkTreeIter *iter,
1414 FindContact *fc)
1415 {
1416 GossipContact *contact;
1417
1418 gtk_tree_model_get (model, iter,
1419 COL_CONTACT, &contact,
1420 -1);
1421
1422 if (!contact) {
1423 return FALSE;
1424 }
1425
1426 if (gossip_contact_equal (contact, fc->contact)) {
1427 fc->found = TRUE;
1428 fc->iters = g_list_append (fc->iters, gtk_tree_iter_copy (iter));
1429 }
1430 g_object_unref (contact);
1431
1432 return FALSE;
1433 }
1434
1435 static GList *
1436 contact_list_store_find_contact (GossipContactListStore *store,
1437 GossipContact *contact)
1438 {
1439 GossipContactListStorePriv *priv;
1440 GtkTreeModel *model;
1441 GList *l = NULL;
1442 FindContact fc;
1443
1444 priv = GET_PRIV (store);
1445
1446 memset (&fc, 0, sizeof (fc));
1447
1448 fc.contact = contact;
1449
1450 model = GTK_TREE_MODEL (store);
1451 gtk_tree_model_foreach (model,
1452 (GtkTreeModelForeachFunc) contact_list_store_find_contact_foreach,
1453 &fc);
1454
1455 if (fc.found) {
1456 l = fc.iters;
1457 }
1458
1459 return l;
1460 }
1461
1462 static gboolean
1463 contact_list_store_update_list_mode_foreach (GtkTreeModel *model,
1464 GtkTreePath *path,
1465 GtkTreeIter *iter,
1466 GossipContactListStore *store)
1467 {
1468 GossipContactListStorePriv *priv;
1469 gboolean show_avatar = FALSE;
1470
1471 priv = GET_PRIV (store);
1472
1473 if (priv->show_avatars && !priv->is_compact) {
1474 show_avatar = TRUE;
1475 }
1476
1477 gtk_tree_store_set (GTK_TREE_STORE (store), iter,
1478 COL_PIXBUF_AVATAR_VISIBLE, show_avatar,
1479 COL_STATUS_VISIBLE, !priv->is_compact,
1480 -1);
1481
1482 return FALSE;
1483 }
1484
empathy mirror