?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Rebase the favourites support upon the telepathy-logger instead of a specially-named...
[empathy-mirror.git] / libempathy-gtk / empathy-contact-list-view.c
blobb95f055802a5185c91b385577bc9af76c21b8a9e
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-2008 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., 51 Franklin St, Fifth Floor,
19 * Boston, MA 02110-1301 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/gi18n-lib.h>
31 #include <gdk/gdkkeysyms.h>
32 #include <gtk/gtk.h>
33
34 #include <telepathy-glib/account-manager.h>
35 #include <telepathy-glib/util.h>
36
37 #include <extensions/extensions.h>
38 #include <libempathy/empathy-call-factory.h>
39 #include <libempathy/empathy-tp-contact-factory.h>
40 #include <libempathy/empathy-contact-list.h>
41 #include <libempathy/empathy-contact-groups.h>
42 #include <libempathy/empathy-dispatcher.h>
43 #include <libempathy/empathy-utils.h>
44
45 #include "empathy-contact-list-view.h"
46 #include "empathy-contact-list-store.h"
47 #include "empathy-images.h"
48 #include "empathy-cell-renderer-expander.h"
49 #include "empathy-cell-renderer-text.h"
50 #include "empathy-cell-renderer-activatable.h"
51 #include "empathy-ui-utils.h"
52 #include "empathy-gtk-enum-types.h"
53 #include "empathy-gtk-marshal.h"
54
55 #define DEBUG_FLAG EMPATHY_DEBUG_CONTACT
56 #include <libempathy/empathy-debug.h>
57
58 /* Active users are those which have recently changed state
59 * (e.g. online, offline or from normal to a busy state).
60 */
61
62 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyContactListView)
63 typedef struct {
64 EmpathyContactListStore *store;
65 GtkTreeRowReference *drag_row;
66 EmpathyContactListFeatureFlags list_features;
67 EmpathyContactFeatureFlags contact_features;
68 GtkWidget *tooltip_widget;
69 GtkTargetList *file_targets;
70 } EmpathyContactListViewPriv;
71
72 typedef struct {
73 EmpathyContactListView *view;
74 GtkTreePath *path;
75 guint timeout_id;
76 } DragMotionData;
77
78 typedef struct {
79 EmpathyContactListView *view;
80 EmpathyContact *contact;
81 gboolean remove;
82 } ShowActiveData;
83
84 enum {
85 PROP_0,
86 PROP_STORE,
87 PROP_LIST_FEATURES,
88 PROP_CONTACT_FEATURES,
89 };
90
91 enum DndDragType {
92 DND_DRAG_TYPE_CONTACT_ID,
93 DND_DRAG_TYPE_URI_LIST,
94 DND_DRAG_TYPE_STRING,
95 };
96
97 static const GtkTargetEntry drag_types_dest[] = {
98 { "text/uri-list", 0, DND_DRAG_TYPE_URI_LIST },
99 { "text/contact-id", 0, DND_DRAG_TYPE_CONTACT_ID },
100 { "text/plain", 0, DND_DRAG_TYPE_STRING },
101 { "STRING", 0, DND_DRAG_TYPE_STRING },
102 };
103
104 static const GtkTargetEntry drag_types_dest_file[] = {
105 { "text/uri-list", 0, DND_DRAG_TYPE_URI_LIST },
106 };
107
108 static const GtkTargetEntry drag_types_source[] = {
109 { "text/contact-id", 0, DND_DRAG_TYPE_CONTACT_ID },
110 };
111
112 static GdkAtom drag_atoms_dest[G_N_ELEMENTS (drag_types_dest)];
113 static GdkAtom drag_atoms_source[G_N_ELEMENTS (drag_types_source)];
114
115 enum {
116 DRAG_CONTACT_RECEIVED,
117 LAST_SIGNAL
118 };
119
120 static guint signals[LAST_SIGNAL];
121
122 G_DEFINE_TYPE (EmpathyContactListView, empathy_contact_list_view, GTK_TYPE_TREE_VIEW);
123
124 static void
125 contact_list_view_tooltip_destroy_cb (GtkWidget *widget,
126 EmpathyContactListView *view)
127 {
128 EmpathyContactListViewPriv *priv = GET_PRIV (view);
129
130 if (priv->tooltip_widget) {
131 DEBUG ("Tooltip destroyed");
132 g_object_unref (priv->tooltip_widget);
133 priv->tooltip_widget = NULL;
134 }
135 }
136
137 static gboolean
138 contact_list_view_query_tooltip_cb (EmpathyContactListView *view,
139 gint x,
140 gint y,
141 gboolean keyboard_mode,
142 GtkTooltip *tooltip,
143 gpointer user_data)
144 {
145 EmpathyContactListViewPriv *priv = GET_PRIV (view);
146 EmpathyContact *contact;
147 GtkTreeModel *model;
148 GtkTreeIter iter;
149 GtkTreePath *path;
150 static gint running = 0;
151 gboolean ret = FALSE;
152
153 /* Avoid an infinite loop. See GNOME bug #574377 */
154 if (running > 0) {
155 return FALSE;
156 }
157 running++;
158
159 /* Don't show the tooltip if there's already a popup menu */
160 if (gtk_menu_get_for_attach_widget (GTK_WIDGET (view)) != NULL) {
161 goto OUT;
162 }
163
164 if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (view), &x, &y,
165 keyboard_mode,
166 &model, &path, &iter)) {
167 goto OUT;
168 }
169
170 gtk_tree_view_set_tooltip_row (GTK_TREE_VIEW (view), tooltip, path);
171 gtk_tree_path_free (path);
172
173 gtk_tree_model_get (model, &iter,
174 EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact,
175 -1);
176 if (!contact) {
177 goto OUT;
178 }
179
180 if (!priv->tooltip_widget) {
181 priv->tooltip_widget = empathy_contact_widget_new (contact,
182 EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP |
183 EMPATHY_CONTACT_WIDGET_SHOW_LOCATION);
184 gtk_container_set_border_width (
185 GTK_CONTAINER (priv->tooltip_widget), 8);
186 g_object_ref (priv->tooltip_widget);
187 g_signal_connect (priv->tooltip_widget, "destroy",
188 G_CALLBACK (contact_list_view_tooltip_destroy_cb),
189 view);
190 gtk_widget_show (priv->tooltip_widget);
191 } else {
192 empathy_contact_widget_set_contact (priv->tooltip_widget,
193 contact);
194 }
195
196 gtk_tooltip_set_custom (tooltip, priv->tooltip_widget);
197 ret = TRUE;
198
199 g_object_unref (contact);
200 OUT:
201 running--;
202
203 return ret;
204 }
205
206 typedef struct {
207 gchar *new_group;
208 gchar *old_group;
209 GdkDragAction action;
210 } DndGetContactData;
211
212 static void
213 contact_list_view_dnd_get_contact_free (DndGetContactData *data)
214 {
215 g_free (data->new_group);
216 g_free (data->old_group);
217 g_slice_free (DndGetContactData, data);
218 }
219
220 static void
221 contact_list_view_drag_got_contact (EmpathyTpContactFactory *factory,
222 EmpathyContact *contact,
223 const GError *error,
224 gpointer user_data,
225 GObject *view)
226 {
227 EmpathyContactListViewPriv *priv = GET_PRIV (view);
228 DndGetContactData *data = user_data;
229 EmpathyContactList *list;
230
231 if (error != NULL) {
232 DEBUG ("Error: %s", error->message);
233 return;
234 }
235
236 DEBUG ("contact %s (%d) dragged from '%s' to '%s'",
237 empathy_contact_get_id (contact),
238 empathy_contact_get_handle (contact),
239 data->old_group, data->new_group);
240
241 list = empathy_contact_list_store_get_list_iface (priv->store);
242 if (data->new_group) {
243 empathy_contact_list_add_to_group (list, contact, data->new_group);
244 }
245 if (data->old_group && data->action == GDK_ACTION_MOVE) {
246 empathy_contact_list_remove_from_group (list, contact, data->old_group);
247 }
248 }
249
250 static gboolean
251 contact_list_view_contact_drag_received (GtkWidget *view,
252 GdkDragContext *context,
253 GtkTreeModel *model,
254 GtkTreePath *path,
255 GtkSelectionData *selection)
256 {
257 EmpathyContactListViewPriv *priv;
258 TpAccountManager *account_manager;
259 EmpathyTpContactFactory *factory = NULL;
260 TpAccount *account;
261 DndGetContactData *data;
262 GtkTreePath *source_path;
263 const gchar *sel_data;
264 gchar **strv = NULL;
265 const gchar *account_id = NULL;
266 const gchar *contact_id = NULL;
267 gchar *new_group = NULL;
268 gchar *old_group = NULL;
269 gboolean success = TRUE;
270
271 priv = GET_PRIV (view);
272
273 sel_data = (const gchar *) gtk_selection_data_get_data (selection);
274 new_group = empathy_contact_list_store_get_parent_group (model,
275 path, NULL);
276
277 /* Get source group information. */
278 if (priv->drag_row) {
279 source_path = gtk_tree_row_reference_get_path (priv->drag_row);
280 if (source_path) {
281 old_group = empathy_contact_list_store_get_parent_group (
282 model, source_path, NULL);
283 gtk_tree_path_free (source_path);
284 }
285 }
286
287 if (!tp_strdiff (old_group, new_group)) {
288 g_free (new_group);
289 g_free (old_group);
290 return FALSE;
291 }
292
293 account_manager = tp_account_manager_dup ();
294 strv = g_strsplit (sel_data, ":", 2);
295 if (g_strv_length (strv) == 2) {
296 account_id = strv[0];
297 contact_id = strv[1];
298 account = tp_account_manager_ensure_account (account_manager, account_id);
299 }
300 if (account) {
301 TpConnection *connection;
302
303 connection = tp_account_get_connection (account);
304 if (connection) {
305 factory = empathy_tp_contact_factory_dup_singleton (connection);
306 }
307 }
308 g_object_unref (account_manager);
309
310 if (!factory) {
311 DEBUG ("Failed to get factory for account '%s'", account_id);
312 success = FALSE;
313 g_free (new_group);
314 g_free (old_group);
315 return FALSE;
316 }
317
318 data = g_slice_new0 (DndGetContactData);
319 data->new_group = new_group;
320 data->old_group = old_group;
321 data->action = context->action;
322
323 /* FIXME: We should probably wait for the cb before calling
324 * gtk_drag_finish */
325 empathy_tp_contact_factory_get_from_id (factory, contact_id,
326 contact_list_view_drag_got_contact,
327 data, (GDestroyNotify) contact_list_view_dnd_get_contact_free,
328 G_OBJECT (view));
329 g_strfreev (strv);
330 g_object_unref (factory);
331
332 return TRUE;
333 }
334
335 static gboolean
336 contact_list_view_file_drag_received (GtkWidget *view,
337 GdkDragContext *context,
338 GtkTreeModel *model,
339 GtkTreePath *path,
340 GtkSelectionData *selection)
341 {
342 GtkTreeIter iter;
343 const gchar *sel_data;
344 EmpathyContact *contact;
345
346 sel_data = (const gchar *) gtk_selection_data_get_data (selection);
347
348 gtk_tree_model_get_iter (model, &iter, path);
349 gtk_tree_model_get (model, &iter,
350 EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact,
351 -1);
352 if (!contact) {
353 return FALSE;
354 }
355
356 empathy_send_file_from_uri_list (contact, sel_data);
357
358 g_object_unref (contact);
359
360 return TRUE;
361 }
362
363 static void
364 contact_list_view_drag_data_received (GtkWidget *view,
365 GdkDragContext *context,
366 gint x,
367 gint y,
368 GtkSelectionData *selection,
369 guint info,
370 guint time_)
371 {
372 GtkTreeModel *model;
373 gboolean is_row;
374 GtkTreeViewDropPosition position;
375 GtkTreePath *path;
376 gboolean success = TRUE;
377
378 model = gtk_tree_view_get_model (GTK_TREE_VIEW (view));
379
380 /* Get destination group information. */
381 is_row = gtk_tree_view_get_dest_row_at_pos (GTK_TREE_VIEW (view),
382 x,
383 y,
384 &path,
385 &position);
386 if (!is_row) {
387 success = FALSE;
388 }
389 else if (info == DND_DRAG_TYPE_CONTACT_ID || info == DND_DRAG_TYPE_STRING) {
390 success = contact_list_view_contact_drag_received (view,
391 context,
392 model,
393 path,
394 selection);
395 }
396 else if (info == DND_DRAG_TYPE_URI_LIST) {
397 success = contact_list_view_file_drag_received (view,
398 context,
399 model,
400 path,
401 selection);
402 }
403
404 gtk_tree_path_free (path);
405 gtk_drag_finish (context, success, FALSE, GDK_CURRENT_TIME);
406 }
407
408 static gboolean
409 contact_list_view_drag_motion_cb (DragMotionData *data)
410 {
411 gtk_tree_view_expand_row (GTK_TREE_VIEW (data->view),
412 data->path,
413 FALSE);
414
415 data->timeout_id = 0;
416
417 return FALSE;
418 }
419
420 static gboolean
421 contact_list_view_drag_motion (GtkWidget *widget,
422 GdkDragContext *context,
423 gint x,
424 gint y,
425 guint time_)
426 {
427 EmpathyContactListViewPriv *priv;
428 GtkTreeModel *model;
429 GdkAtom target;
430 GtkTreeIter iter;
431 static DragMotionData *dm = NULL;
432 GtkTreePath *path;
433 gboolean is_row;
434 gboolean is_different = FALSE;
435 gboolean cleanup = TRUE;
436 gboolean retval = TRUE;
437
438 priv = GET_PRIV (EMPATHY_CONTACT_LIST_VIEW (widget));
439 model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
440
441 is_row = gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
442 x,
443 y,
444 &path,
445 NULL,
446 NULL,
447 NULL);
448
449 cleanup &= (!dm);
450
451 if (is_row) {
452 cleanup &= (dm && gtk_tree_path_compare (dm->path, path) != 0);
453 is_different = (!dm || (dm && gtk_tree_path_compare (dm->path, path) != 0));
454 } else {
455 cleanup &= FALSE;
456 }
457
458 if (path == NULL) {
459 /* Coordinates don't point to an actual row, so make sure the pointer
460 and highlighting don't indicate that a drag is possible.
461 */
462 gdk_drag_status (context, GDK_ACTION_DEFAULT, time_);
463 gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget), NULL, 0);
464 return FALSE;
465 }
466 target = gtk_drag_dest_find_target (widget, context, priv->file_targets);
467 gtk_tree_model_get_iter (model, &iter, path);
468
469 if (target == GDK_NONE) {
470 /* If target == GDK_NONE, then we don't have a target that can be
471 dropped on a contact. This means a contact drag. If we're
472 pointing to a group, highlight it. Otherwise, if the contact
473 we're pointing to is in a group, highlight that. Otherwise,
474 set the drag position to before the first row for a drag into
475 the "non-group" at the top.
476 */
477 GtkTreeIter group_iter;
478 gboolean is_group;
479 GtkTreePath *group_path;
480 gtk_tree_model_get (model, &iter,
481 EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group,
482 -1);
483 if (is_group) {
484 group_iter = iter;
485 }
486 else {
487 if (gtk_tree_model_iter_parent (model, &group_iter, &iter))
488 gtk_tree_model_get (model, &group_iter,
489 EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group,
490 -1);
491 }
492 if (is_group) {
493 gdk_drag_status (context, GDK_ACTION_MOVE, time_);
494 group_path = gtk_tree_model_get_path (model, &group_iter);
495 gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
496 group_path,
497 GTK_TREE_VIEW_DROP_INTO_OR_BEFORE);
498 gtk_tree_path_free (group_path);
499 }
500 else {
501 group_path = gtk_tree_path_new_first ();
502 gdk_drag_status (context, GDK_ACTION_MOVE, time_);
503 gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
504 group_path,
505 GTK_TREE_VIEW_DROP_BEFORE);
506 }
507 }
508 else {
509 /* This is a file drag, and it can only be dropped on contacts,
510 not groups.
511 */
512 EmpathyContact *contact;
513 gtk_tree_model_get (model, &iter,
514 EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact,
515 -1);
516 if (contact != NULL &&
517 empathy_contact_is_online (contact) &&
518 (empathy_contact_get_capabilities (contact) & EMPATHY_CAPABILITIES_FT)) {
519 gdk_drag_status (context, GDK_ACTION_COPY, time_);
520 gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget),
521 path,
522 GTK_TREE_VIEW_DROP_INTO_OR_BEFORE);
523 g_object_unref (contact);
524 }
525 else {
526 gdk_drag_status (context, 0, time_);
527 gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (widget), NULL, 0);
528 retval = FALSE;
529 }
530 }
531
532 if (!is_different && !cleanup) {
533 return retval;
534 }
535
536 if (dm) {
537 gtk_tree_path_free (dm->path);
538 if (dm->timeout_id) {
539 g_source_remove (dm->timeout_id);
540 }
541
542 g_free (dm);
543
544 dm = NULL;
545 }
546
547 if (!gtk_tree_view_row_expanded (GTK_TREE_VIEW (widget), path)) {
548 dm = g_new0 (DragMotionData, 1);
549
550 dm->view = EMPATHY_CONTACT_LIST_VIEW (widget);
551 dm->path = gtk_tree_path_copy (path);
552
553 dm->timeout_id = g_timeout_add_seconds (1,
554 (GSourceFunc) contact_list_view_drag_motion_cb,
555 dm);
556 }
557
558 return retval;
559 }
560
561 static void
562 contact_list_view_drag_begin (GtkWidget *widget,
563 GdkDragContext *context)
564 {
565 EmpathyContactListViewPriv *priv;
566 GtkTreeSelection *selection;
567 GtkTreeModel *model;
568 GtkTreePath *path;
569 GtkTreeIter iter;
570
571 priv = GET_PRIV (widget);
572
573 GTK_WIDGET_CLASS (empathy_contact_list_view_parent_class)->drag_begin (widget,
574 context);
575
576 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
577 if (!gtk_tree_selection_get_selected (selection, &model, &iter)) {
578 return;
579 }
580
581 path = gtk_tree_model_get_path (model, &iter);
582 priv->drag_row = gtk_tree_row_reference_new (model, path);
583 gtk_tree_path_free (path);
584 }
585
586 static void
587 contact_list_view_drag_data_get (GtkWidget *widget,
588 GdkDragContext *context,
589 GtkSelectionData *selection,
590 guint info,
591 guint time_)
592 {
593 EmpathyContactListViewPriv *priv;
594 GtkTreePath *src_path;
595 GtkTreeIter iter;
596 GtkTreeModel *model;
597 EmpathyContact *contact;
598 TpAccount *account;
599 const gchar *contact_id;
600 const gchar *account_id;
601 gchar *str;
602
603 priv = GET_PRIV (widget);
604
605 model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
606 if (!priv->drag_row) {
607 return;
608 }
609
610 src_path = gtk_tree_row_reference_get_path (priv->drag_row);
611 if (!src_path) {
612 return;
613 }
614
615 if (!gtk_tree_model_get_iter (model, &iter, src_path)) {
616 gtk_tree_path_free (src_path);
617 return;
618 }
619
620 gtk_tree_path_free (src_path);
621
622 contact = empathy_contact_list_view_dup_selected (EMPATHY_CONTACT_LIST_VIEW (widget));
623 if (!contact) {
624 return;
625 }
626
627 account = empathy_contact_get_account (contact);
628 account_id = tp_proxy_get_object_path (account);
629 contact_id = empathy_contact_get_id (contact);
630 g_object_unref (contact);
631 str = g_strconcat (account_id, ":", contact_id, NULL);
632
633 switch (info) {
634 case DND_DRAG_TYPE_CONTACT_ID:
635 gtk_selection_data_set (selection, drag_atoms_source[info], 8,
636 (guchar *) str, strlen (str) + 1);
637 break;
638 }
639
640 g_free (str);
641 }
642
643 static void
644 contact_list_view_drag_end (GtkWidget *widget,
645 GdkDragContext *context)
646 {
647 EmpathyContactListViewPriv *priv;
648
649 priv = GET_PRIV (widget);
650
651 GTK_WIDGET_CLASS (empathy_contact_list_view_parent_class)->drag_end (widget,
652 context);
653
654 if (priv->drag_row) {
655 gtk_tree_row_reference_free (priv->drag_row);
656 priv->drag_row = NULL;
657 }
658 }
659
660 static gboolean
661 contact_list_view_drag_drop (GtkWidget *widget,
662 GdkDragContext *drag_context,
663 gint x,
664 gint y,
665 guint time_)
666 {
667 return FALSE;
668 }
669
670 typedef struct {
671 EmpathyContactListView *view;
672 guint button;
673 guint32 time;
674 } MenuPopupData;
675
676 static gboolean
677 contact_list_view_popup_menu_idle_cb (gpointer user_data)
678 {
679 MenuPopupData *data = user_data;
680 GtkWidget *menu;
681
682 menu = empathy_contact_list_view_get_contact_menu (data->view);
683 if (!menu) {
684 menu = empathy_contact_list_view_get_group_menu (data->view);
685 }
686
687 if (menu) {
688 g_signal_connect (menu, "deactivate",
689 G_CALLBACK (gtk_menu_detach), NULL);
690 gtk_menu_attach_to_widget (GTK_MENU (menu),
691 GTK_WIDGET (data->view), NULL);
692 gtk_widget_show (menu);
693 gtk_menu_popup (GTK_MENU (menu),
694 NULL, NULL, NULL, NULL,
695 data->button, data->time);
696 g_object_ref_sink (menu);
697 g_object_unref (menu);
698 }
699
700 g_slice_free (MenuPopupData, data);
701
702 return FALSE;
703 }
704
705 static gboolean
706 contact_list_view_button_press_event_cb (EmpathyContactListView *view,
707 GdkEventButton *event,
708 gpointer user_data)
709 {
710 if (event->button == 3) {
711 MenuPopupData *data;
712
713 data = g_slice_new (MenuPopupData);
714 data->view = view;
715 data->button = event->button;
716 data->time = event->time;
717 g_idle_add (contact_list_view_popup_menu_idle_cb, data);
718 }
719
720 return FALSE;
721 }
722
723 static gboolean
724 contact_list_view_key_press_event_cb (EmpathyContactListView *view,
725 GdkEventKey *event,
726 gpointer user_data)
727 {
728 if (event->keyval == GDK_Menu) {
729 MenuPopupData *data;
730
731 data = g_slice_new (MenuPopupData);
732 data->view = view;
733 data->button = 0;
734 data->time = event->time;
735 g_idle_add (contact_list_view_popup_menu_idle_cb, data);
736 }
737
738 return FALSE;
739 }
740
741 static void
742 contact_list_view_row_activated (GtkTreeView *view,
743 GtkTreePath *path,
744 GtkTreeViewColumn *column)
745 {
746 EmpathyContactListViewPriv *priv = GET_PRIV (view);
747 EmpathyContact *contact;
748 GtkTreeModel *model;
749 GtkTreeIter iter;
750
751 if (!(priv->contact_features & EMPATHY_CONTACT_FEATURE_CHAT)) {
752 return;
753 }
754
755 model = GTK_TREE_MODEL (priv->store);
756 gtk_tree_model_get_iter (model, &iter, path);
757 gtk_tree_model_get (model, &iter,
758 EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact,
759 -1);
760
761 if (contact) {
762 DEBUG ("Starting a chat");
763 empathy_dispatcher_chat_with_contact (contact, NULL, NULL);
764 g_object_unref (contact);
765 }
766 }
767
768 static void
769 contact_list_view_call_activated_cb (
770 EmpathyCellRendererActivatable *cell,
771 const gchar *path_string,
772 EmpathyContactListView *view)
773 {
774 GtkWidget *menu;
775 GtkTreeModel *model;
776 GtkTreeIter iter;
777 EmpathyContact *contact;
778 GdkEventButton *event;
779 GtkMenuShell *shell;
780 GtkWidget *item;
781
782 model = gtk_tree_view_get_model (GTK_TREE_VIEW (view));
783 if (!gtk_tree_model_get_iter_from_string (model, &iter, path_string))
784 return;
785
786 gtk_tree_model_get (model, &iter,
787 EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact,
788 -1);
789 if (contact == NULL)
790 return;
791
792 event = (GdkEventButton *) gtk_get_current_event ();
793
794 menu = gtk_menu_new ();
795 shell = GTK_MENU_SHELL (menu);
796
797 /* audio */
798 item = empathy_contact_audio_call_menu_item_new (contact);
799 gtk_menu_shell_append (shell, item);
800 gtk_widget_show (item);
801
802 /* video */
803 item = empathy_contact_video_call_menu_item_new (contact);
804 gtk_menu_shell_append (shell, item);
805 gtk_widget_show (item);
806
807 g_signal_connect (menu, "deactivate",
808 G_CALLBACK (gtk_menu_detach), NULL);
809 gtk_menu_attach_to_widget (GTK_MENU (menu),
810 GTK_WIDGET (view), NULL);
811 gtk_widget_show (menu);
812 gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
813 event->button, event->time);
814 g_object_ref_sink (menu);
815 g_object_unref (menu);
816
817 g_object_unref (contact);
818 }
819
820 #if HAVE_FAVOURITE_CONTACTS
821 static void
822 contact_list_view_favourite_toggled_cb (
823 EmpathyCellRendererActivatable *cell,
824 const gchar *path_string,
825 EmpathyContactListView *view)
826 {
827 EmpathyContactListViewPriv *priv = GET_PRIV (view);
828 GtkTreeModel *model;
829 GtkTreeIter iter;
830 EmpathyContact *contact;
831 EmpathyContactList *list;
832
833 model = gtk_tree_view_get_model (GTK_TREE_VIEW (view));
834 if (!gtk_tree_model_get_iter_from_string (model, &iter, path_string))
835 return;
836
837 gtk_tree_model_get (model, &iter,
838 EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact,
839 -1);
840 if (contact == NULL)
841 return;
842
843 list = empathy_contact_list_store_get_list_iface (priv->store);
844 if (empathy_contact_list_is_favourite (list, contact)) {
845 empathy_contact_list_remove_from_favourites (list, contact);
846 } else {
847 empathy_contact_list_add_to_favourites (list, contact);
848 }
849
850 g_object_unref (contact);
851 }
852 #endif /* HAVE_FAVOURITE_CONTACTS */
853
854 static void
855 contact_list_view_cell_set_background (EmpathyContactListView *view,
856 GtkCellRenderer *cell,
857 gboolean is_group,
858 gboolean is_active)
859 {
860 GdkColor color;
861 GtkStyle *style;
862
863 style = gtk_widget_get_style (GTK_WIDGET (view));
864
865 if (!is_group && is_active) {
866 color = style->bg[GTK_STATE_SELECTED];
867
868 /* Here we take the current theme colour and add it to
869 * the colour for white and average the two. This
870 * gives a colour which is inline with the theme but
871 * slightly whiter.
872 */
873 color.red = (color.red + (style->white).red) / 2;
874 color.green = (color.green + (style->white).green) / 2;
875 color.blue = (color.blue + (style->white).blue) / 2;
876
877 g_object_set (cell,
878 "cell-background-gdk", &color,
879 NULL);
880 } else {
881 g_object_set (cell,
882 "cell-background-gdk", NULL,
883 NULL);
884 }
885 }
886
887 static void
888 contact_list_view_pixbuf_cell_data_func (GtkTreeViewColumn *tree_column,
889 GtkCellRenderer *cell,
890 GtkTreeModel *model,
891 GtkTreeIter *iter,
892 EmpathyContactListView *view)
893 {
894 GdkPixbuf *pixbuf;
895 gboolean is_group;
896 gboolean is_active;
897
898 gtk_tree_model_get (model, iter,
899 EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group,
900 EMPATHY_CONTACT_LIST_STORE_COL_IS_ACTIVE, &is_active,
901 EMPATHY_CONTACT_LIST_STORE_COL_ICON_STATUS, &pixbuf,
902 -1);
903
904 g_object_set (cell,
905 "visible", !is_group,
906 "pixbuf", pixbuf,
907 NULL);
908
909 if (pixbuf != NULL) {
910 g_object_unref (pixbuf);
911 }
912
913 contact_list_view_cell_set_background (view, cell, is_group, is_active);
914 }
915
916 static void
917 contact_list_view_audio_call_cell_data_func (
918 GtkTreeViewColumn *tree_column,
919 GtkCellRenderer *cell,
920 GtkTreeModel *model,
921 GtkTreeIter *iter,
922 EmpathyContactListView *view)
923 {
924 gboolean is_group;
925 gboolean is_active;
926 gboolean can_audio, can_video;
927
928 gtk_tree_model_get (model, iter,
929 EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group,
930 EMPATHY_CONTACT_LIST_STORE_COL_IS_ACTIVE, &is_active,
931 EMPATHY_CONTACT_LIST_STORE_COL_CAN_AUDIO_CALL, &can_audio,
932 EMPATHY_CONTACT_LIST_STORE_COL_CAN_VIDEO_CALL, &can_video,
933 -1);
934
935 g_object_set (cell,
936 "visible", !is_group && (can_audio || can_video),
937 "icon-name", can_video? EMPATHY_IMAGE_VIDEO_CALL : EMPATHY_IMAGE_VOIP,
938 NULL);
939
940 contact_list_view_cell_set_background (view, cell, is_group, is_active);
941 }
942
943 static void
944 contact_list_view_avatar_cell_data_func (GtkTreeViewColumn *tree_column,
945 GtkCellRenderer *cell,
946 GtkTreeModel *model,
947 GtkTreeIter *iter,
948 EmpathyContactListView *view)
949 {
950 GdkPixbuf *pixbuf;
951 gboolean show_avatar;
952 gboolean is_group;
953 gboolean is_active;
954
955 gtk_tree_model_get (model, iter,
956 EMPATHY_CONTACT_LIST_STORE_COL_PIXBUF_AVATAR, &pixbuf,
957 EMPATHY_CONTACT_LIST_STORE_COL_PIXBUF_AVATAR_VISIBLE, &show_avatar,
958 EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group,
959 EMPATHY_CONTACT_LIST_STORE_COL_IS_ACTIVE, &is_active,
960 -1);
961
962 g_object_set (cell,
963 "visible", !is_group && show_avatar,
964 "pixbuf", pixbuf,
965 NULL);
966
967 if (pixbuf) {
968 g_object_unref (pixbuf);
969 }
970
971 contact_list_view_cell_set_background (view, cell, is_group, is_active);
972 }
973
974 static void
975 contact_list_view_text_cell_data_func (GtkTreeViewColumn *tree_column,
976 GtkCellRenderer *cell,
977 GtkTreeModel *model,
978 GtkTreeIter *iter,
979 EmpathyContactListView *view)
980 {
981 gboolean is_group;
982 gboolean is_active;
983 gboolean show_status;
984 gchar *name;
985
986 gtk_tree_model_get (model, iter,
987 EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group,
988 EMPATHY_CONTACT_LIST_STORE_COL_IS_ACTIVE, &is_active,
989 EMPATHY_CONTACT_LIST_STORE_COL_STATUS_VISIBLE, &show_status,
990 EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name,
991 -1);
992
993 g_object_set (cell,
994 "show-status", show_status,
995 "text", name,
996 NULL);
997 g_free (name);
998
999 contact_list_view_cell_set_background (view, cell, is_group, is_active);
1000 }
1001
1002 static void
1003 contact_list_view_expander_cell_data_func (GtkTreeViewColumn *column,
1004 GtkCellRenderer *cell,
1005 GtkTreeModel *model,
1006 GtkTreeIter *iter,
1007 EmpathyContactListView *view)
1008 {
1009 gboolean is_group;
1010 gboolean is_active;
1011
1012 gtk_tree_model_get (model, iter,
1013 EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group,
1014 EMPATHY_CONTACT_LIST_STORE_COL_IS_ACTIVE, &is_active,
1015 -1);
1016
1017 if (gtk_tree_model_iter_has_child (model, iter)) {
1018 GtkTreePath *path;
1019 gboolean row_expanded;
1020
1021 path = gtk_tree_model_get_path (model, iter);
1022 row_expanded = gtk_tree_view_row_expanded (GTK_TREE_VIEW (gtk_tree_view_column_get_tree_view (column)), path);
1023 gtk_tree_path_free (path);
1024
1025 g_object_set (cell,
1026 "visible", TRUE,
1027 "expander-style", row_expanded ? GTK_EXPANDER_EXPANDED : GTK_EXPANDER_COLLAPSED,
1028 NULL);
1029 } else {
1030 g_object_set (cell, "visible", FALSE, NULL);
1031 }
1032
1033 contact_list_view_cell_set_background (view, cell, is_group, is_active);
1034 }
1035
1036 #if HAVE_FAVOURITE_CONTACTS
1037 static void
1038 contact_list_view_favourite_cell_data_func (
1039 GtkTreeViewColumn *tree_column,
1040 GtkCellRenderer *cell,
1041 GtkTreeModel *model,
1042 GtkTreeIter *iter,
1043 EmpathyContactListView *view)
1044 {
1045 gboolean is_group;
1046 gboolean is_active;
1047 gboolean is_separator;
1048 gboolean is_favourite;
1049 const gchar *icon_name = NULL;
1050
1051 gtk_tree_model_get (model, iter,
1052 EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group,
1053 EMPATHY_CONTACT_LIST_STORE_COL_IS_ACTIVE, &is_active,
1054 EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, &is_separator,
1055 EMPATHY_CONTACT_LIST_STORE_COL_IS_FAVOURITE, &is_favourite,
1056 -1);
1057
1058 if (!is_separator && !is_group)
1059 icon_name = (is_favourite? EMPATHY_IMAGE_FAVOURITE :
1060 EMPATHY_IMAGE_UNFAVOURITE);
1061
1062 g_object_set (cell,
1063 "visible", (icon_name != NULL),
1064 "icon-name", icon_name,
1065 NULL);
1066
1067 contact_list_view_cell_set_background (view, cell, is_group, is_active);
1068 }
1069 #endif /* HAVE_FAVOURITE_CONTACTS */
1070
1071 static void
1072 contact_list_view_row_expand_or_collapse_cb (EmpathyContactListView *view,
1073 GtkTreeIter *iter,
1074 GtkTreePath *path,
1075 gpointer user_data)
1076 {
1077 EmpathyContactListViewPriv *priv = GET_PRIV (view);
1078 GtkTreeModel *model;
1079 gchar *name;
1080 gboolean expanded;
1081
1082 if (!(priv->list_features & EMPATHY_CONTACT_LIST_FEATURE_GROUPS_SAVE)) {
1083 return;
1084 }
1085
1086 model = gtk_tree_view_get_model (GTK_TREE_VIEW (view));
1087
1088 gtk_tree_model_get (model, iter,
1089 EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name,
1090 -1);
1091
1092 expanded = GPOINTER_TO_INT (user_data);
1093 empathy_contact_group_set_expanded (name, expanded);
1094
1095 g_free (name);
1096 }
1097
1098 static void
1099 contact_list_view_row_has_child_toggled_cb (GtkTreeModel *model,
1100 GtkTreePath *path,
1101 GtkTreeIter *iter,
1102 EmpathyContactListView *view)
1103 {
1104 EmpathyContactListViewPriv *priv = GET_PRIV (view);
1105 gboolean is_group = FALSE;
1106 gchar *name = NULL;
1107
1108 gtk_tree_model_get (model, iter,
1109 EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group,
1110 EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name,
1111 -1);
1112
1113 if (!is_group || EMP_STR_EMPTY (name)) {
1114 g_free (name);
1115 return;
1116 }
1117
1118 if (!(priv->list_features & EMPATHY_CONTACT_LIST_FEATURE_GROUPS_SAVE) ||
1119 empathy_contact_group_get_expanded (name)) {
1120 g_signal_handlers_block_by_func (view,
1121 contact_list_view_row_expand_or_collapse_cb,
1122 GINT_TO_POINTER (TRUE));
1123 gtk_tree_view_expand_row (GTK_TREE_VIEW (view), path, TRUE);
1124 g_signal_handlers_unblock_by_func (view,
1125 contact_list_view_row_expand_or_collapse_cb,
1126 GINT_TO_POINTER (TRUE));
1127 } else {
1128 g_signal_handlers_block_by_func (view,
1129 contact_list_view_row_expand_or_collapse_cb,
1130 GINT_TO_POINTER (FALSE));
1131 gtk_tree_view_collapse_row (GTK_TREE_VIEW (view), path);
1132 g_signal_handlers_unblock_by_func (view,
1133 contact_list_view_row_expand_or_collapse_cb,
1134 GINT_TO_POINTER (FALSE));
1135 }
1136
1137 g_free (name);
1138 }
1139
1140 static void
1141 contact_list_view_setup (EmpathyContactListView *view)
1142 {
1143 EmpathyContactListViewPriv *priv;
1144 GtkCellRenderer *cell;
1145 GtkTreeViewColumn *col;
1146 guint i;
1147
1148 priv = GET_PRIV (view);
1149
1150 gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (view),
1151 empathy_contact_list_store_search_equal_func,
1152 NULL, NULL);
1153
1154 g_signal_connect (priv->store, "row-has-child-toggled",
1155 G_CALLBACK (contact_list_view_row_has_child_toggled_cb),
1156 view);
1157 gtk_tree_view_set_model (GTK_TREE_VIEW (view),
1158 GTK_TREE_MODEL (priv->store));
1159
1160 /* Setup view */
1161 /* Setting reorderable is a hack that gets us row previews as drag icons
1162 for free. We override all the drag handlers. It's tricky to get the
1163 position of the drag icon right in drag_begin. GtkTreeView has special
1164 voodoo for it, so we let it do the voodoo that he do.
1165 */
1166 g_object_set (view,
1167 "headers-visible", FALSE,
1168 "reorderable", TRUE,
1169 "show-expanders", FALSE,
1170 NULL);
1171
1172 col = gtk_tree_view_column_new ();
1173
1174 #if HAVE_FAVOURITE_CONTACTS
1175 /* Favourite Icon */
1176 cell = empathy_cell_renderer_activatable_new ();
1177 gtk_tree_view_column_pack_start (col, cell, FALSE);
1178 gtk_tree_view_column_set_cell_data_func (
1179 col, cell,
1180 (GtkTreeCellDataFunc) contact_list_view_favourite_cell_data_func,
1181 view, NULL);
1182
1183 g_object_set (cell,
1184 "visible", FALSE,
1185 NULL);
1186
1187 g_signal_connect (cell, "path-activated",
1188 G_CALLBACK (contact_list_view_favourite_toggled_cb),
1189 view);
1190 #endif
1191
1192 /* State */
1193 cell = gtk_cell_renderer_pixbuf_new ();
1194 gtk_tree_view_column_pack_start (col, cell, FALSE);
1195 gtk_tree_view_column_set_cell_data_func (
1196 col, cell,
1197 (GtkTreeCellDataFunc) contact_list_view_pixbuf_cell_data_func,
1198 view, NULL);
1199
1200 g_object_set (cell,
1201 "xpad", 5,
1202 "ypad", 1,
1203 "visible", FALSE,
1204 NULL);
1205
1206 /* Name */
1207 cell = empathy_cell_renderer_text_new ();
1208 gtk_tree_view_column_pack_start (col, cell, TRUE);
1209 gtk_tree_view_column_set_cell_data_func (
1210 col, cell,
1211 (GtkTreeCellDataFunc) contact_list_view_text_cell_data_func,
1212 view, NULL);
1213
1214 gtk_tree_view_column_add_attribute (col, cell,
1215 "name", EMPATHY_CONTACT_LIST_STORE_COL_NAME);
1216 gtk_tree_view_column_add_attribute (col, cell,
1217 "status", EMPATHY_CONTACT_LIST_STORE_COL_STATUS);
1218 gtk_tree_view_column_add_attribute (col, cell,
1219 "is_group", EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP);
1220
1221 /* Audio Call Icon */
1222 cell = empathy_cell_renderer_activatable_new ();
1223 gtk_tree_view_column_pack_start (col, cell, FALSE);
1224 gtk_tree_view_column_set_cell_data_func (
1225 col, cell,
1226 (GtkTreeCellDataFunc) contact_list_view_audio_call_cell_data_func,
1227 view, NULL);
1228
1229 g_object_set (cell,
1230 "visible", FALSE,
1231 NULL);
1232
1233 g_signal_connect (cell, "path-activated",
1234 G_CALLBACK (contact_list_view_call_activated_cb),
1235 view);
1236
1237 /* Avatar */
1238 cell = gtk_cell_renderer_pixbuf_new ();
1239 gtk_tree_view_column_pack_start (col, cell, FALSE);
1240 gtk_tree_view_column_set_cell_data_func (
1241 col, cell,
1242 (GtkTreeCellDataFunc) contact_list_view_avatar_cell_data_func,
1243 view, NULL);
1244
1245 g_object_set (cell,
1246 "xpad", 0,
1247 "ypad", 0,
1248 "visible", FALSE,
1249 "width", 32,
1250 "height", 32,
1251 NULL);
1252
1253 /* Expander */
1254 cell = empathy_cell_renderer_expander_new ();
1255 gtk_tree_view_column_pack_end (col, cell, FALSE);
1256 gtk_tree_view_column_set_cell_data_func (
1257 col, cell,
1258 (GtkTreeCellDataFunc) contact_list_view_expander_cell_data_func,
1259 view, NULL);
1260
1261 /* Actually add the column now we have added all cell renderers */
1262 gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
1263
1264 /* Drag & Drop. */
1265 for (i = 0; i < G_N_ELEMENTS (drag_types_dest); ++i) {
1266 drag_atoms_dest[i] = gdk_atom_intern (drag_types_dest[i].target,
1267 FALSE);
1268 }
1269
1270 for (i = 0; i < G_N_ELEMENTS (drag_types_source); ++i) {
1271 drag_atoms_source[i] = gdk_atom_intern (drag_types_source[i].target,
1272 FALSE);
1273 }
1274 }
1275
1276 static void
1277 contact_list_view_set_list_features (EmpathyContactListView *view,
1278 EmpathyContactListFeatureFlags features)
1279 {
1280 EmpathyContactListViewPriv *priv = GET_PRIV (view);
1281 gboolean has_tooltip;
1282
1283 g_return_if_fail (EMPATHY_IS_CONTACT_LIST_VIEW (view));
1284
1285 priv->list_features = features;
1286
1287 /* Update DnD source/dest */
1288 if (features & EMPATHY_CONTACT_LIST_FEATURE_CONTACT_DRAG) {
1289 gtk_drag_source_set (GTK_WIDGET (view),
1290 GDK_BUTTON1_MASK,
1291 drag_types_source,
1292 G_N_ELEMENTS (drag_types_source),
1293 GDK_ACTION_MOVE | GDK_ACTION_COPY);
1294 } else {
1295 gtk_drag_source_unset (GTK_WIDGET (view));
1296
1297 }
1298
1299 if (features & EMPATHY_CONTACT_LIST_FEATURE_CONTACT_DROP) {
1300 gtk_drag_dest_set (GTK_WIDGET (view),
1301 GTK_DEST_DEFAULT_ALL,
1302 drag_types_dest,
1303 G_N_ELEMENTS (drag_types_dest),
1304 GDK_ACTION_MOVE | GDK_ACTION_COPY);
1305 } else {
1306 /* FIXME: URI could still be droped depending on FT feature */
1307 gtk_drag_dest_unset (GTK_WIDGET (view));
1308 }
1309
1310 /* Update has-tooltip */
1311 has_tooltip = (features & EMPATHY_CONTACT_LIST_FEATURE_CONTACT_TOOLTIP) != 0;
1312 gtk_widget_set_has_tooltip (GTK_WIDGET (view), has_tooltip);
1313 }
1314
1315 static void
1316 contact_list_view_finalize (GObject *object)
1317 {
1318 EmpathyContactListViewPriv *priv;
1319
1320 priv = GET_PRIV (object);
1321
1322 if (priv->store) {
1323 g_object_unref (priv->store);
1324 }
1325 if (priv->tooltip_widget) {
1326 gtk_widget_destroy (priv->tooltip_widget);
1327 }
1328 if (priv->file_targets) {
1329 gtk_target_list_unref (priv->file_targets);
1330 }
1331
1332 G_OBJECT_CLASS (empathy_contact_list_view_parent_class)->finalize (object);
1333 }
1334
1335 static void
1336 contact_list_view_get_property (GObject *object,
1337 guint param_id,
1338 GValue *value,
1339 GParamSpec *pspec)
1340 {
1341 EmpathyContactListViewPriv *priv;
1342
1343 priv = GET_PRIV (object);
1344
1345 switch (param_id) {
1346 case PROP_STORE:
1347 g_value_set_object (value, priv->store);
1348 break;
1349 case PROP_LIST_FEATURES:
1350 g_value_set_flags (value, priv->list_features);
1351 break;
1352 case PROP_CONTACT_FEATURES:
1353 g_value_set_flags (value, priv->contact_features);
1354 break;
1355 default:
1356 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
1357 break;
1358 };
1359 }
1360
1361 static void
1362 contact_list_view_set_property (GObject *object,
1363 guint param_id,
1364 const GValue *value,
1365 GParamSpec *pspec)
1366 {
1367 EmpathyContactListView *view = EMPATHY_CONTACT_LIST_VIEW (object);
1368 EmpathyContactListViewPriv *priv = GET_PRIV (object);
1369
1370 switch (param_id) {
1371 case PROP_STORE:
1372 priv->store = g_value_dup_object (value);
1373 contact_list_view_setup (view);
1374 break;
1375 case PROP_LIST_FEATURES:
1376 contact_list_view_set_list_features (view, g_value_get_flags (value));
1377 break;
1378 case PROP_CONTACT_FEATURES:
1379 priv->contact_features = g_value_get_flags (value);
1380 break;
1381 default:
1382 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
1383 break;
1384 };
1385 }
1386
1387 static void
1388 empathy_contact_list_view_class_init (EmpathyContactListViewClass *klass)
1389 {
1390 GObjectClass *object_class = G_OBJECT_CLASS (klass);
1391 GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
1392 GtkTreeViewClass *tree_view_class = GTK_TREE_VIEW_CLASS (klass);
1393
1394 object_class->finalize = contact_list_view_finalize;
1395 object_class->get_property = contact_list_view_get_property;
1396 object_class->set_property = contact_list_view_set_property;
1397
1398 widget_class->drag_data_received = contact_list_view_drag_data_received;
1399 widget_class->drag_drop = contact_list_view_drag_drop;
1400 widget_class->drag_begin = contact_list_view_drag_begin;
1401 widget_class->drag_data_get = contact_list_view_drag_data_get;
1402 widget_class->drag_end = contact_list_view_drag_end;
1403 widget_class->drag_motion = contact_list_view_drag_motion;
1404
1405 /* We use the class method to let user of this widget to connect to
1406 * the signal and stop emission of the signal so the default handler
1407 * won't be called. */
1408 tree_view_class->row_activated = contact_list_view_row_activated;
1409
1410 signals[DRAG_CONTACT_RECEIVED] =
1411 g_signal_new ("drag-contact-received",
1412 G_OBJECT_CLASS_TYPE (klass),
1413 G_SIGNAL_RUN_LAST,
1414 0,
1415 NULL, NULL,
1416 _empathy_gtk_marshal_VOID__OBJECT_STRING_STRING,
1417 G_TYPE_NONE,
1418 3, EMPATHY_TYPE_CONTACT, G_TYPE_STRING, G_TYPE_STRING);
1419
1420 g_object_class_install_property (object_class,
1421 PROP_STORE,
1422 g_param_spec_object ("store",
1423 "The store of the view",
1424 "The store of the view",
1425 EMPATHY_TYPE_CONTACT_LIST_STORE,
1426 G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
1427 g_object_class_install_property (object_class,
1428 PROP_LIST_FEATURES,
1429 g_param_spec_flags ("list-features",
1430 "Features of the view",
1431 "Falgs for all enabled features",
1432 EMPATHY_TYPE_CONTACT_LIST_FEATURE_FLAGS,
1433 EMPATHY_CONTACT_LIST_FEATURE_NONE,
1434 G_PARAM_READWRITE));
1435 g_object_class_install_property (object_class,
1436 PROP_CONTACT_FEATURES,
1437 g_param_spec_flags ("contact-features",
1438 "Features of the contact menu",
1439 "Falgs for all enabled features for the menu",
1440 EMPATHY_TYPE_CONTACT_FEATURE_FLAGS,
1441 EMPATHY_CONTACT_FEATURE_NONE,
1442 G_PARAM_READWRITE));
1443
1444 g_type_class_add_private (object_class, sizeof (EmpathyContactListViewPriv));
1445 }
1446
1447 static void
1448 empathy_contact_list_view_init (EmpathyContactListView *view)
1449 {
1450 EmpathyContactListViewPriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (view,
1451 EMPATHY_TYPE_CONTACT_LIST_VIEW, EmpathyContactListViewPriv);
1452
1453 view->priv = priv;
1454 /* Get saved group states. */
1455 empathy_contact_groups_get_all ();
1456
1457 gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (view),
1458 empathy_contact_list_store_row_separator_func,
1459 NULL, NULL);
1460
1461 /* Set up drag target lists. */
1462 priv->file_targets = gtk_target_list_new (drag_types_dest_file,
1463 G_N_ELEMENTS (drag_types_dest_file));
1464
1465 /* Connect to tree view signals rather than override. */
1466 g_signal_connect (view, "button-press-event",
1467 G_CALLBACK (contact_list_view_button_press_event_cb),
1468 NULL);
1469 g_signal_connect (view, "key-press-event",
1470 G_CALLBACK (contact_list_view_key_press_event_cb),
1471 NULL);
1472 g_signal_connect (view, "row-expanded",
1473 G_CALLBACK (contact_list_view_row_expand_or_collapse_cb),
1474 GINT_TO_POINTER (TRUE));
1475 g_signal_connect (view, "row-collapsed",
1476 G_CALLBACK (contact_list_view_row_expand_or_collapse_cb),
1477 GINT_TO_POINTER (FALSE));
1478 g_signal_connect (view, "query-tooltip",
1479 G_CALLBACK (contact_list_view_query_tooltip_cb),
1480 NULL);
1481 }
1482
1483 EmpathyContactListView *
1484 empathy_contact_list_view_new (EmpathyContactListStore *store,
1485 EmpathyContactListFeatureFlags list_features,
1486 EmpathyContactFeatureFlags contact_features)
1487 {
1488 g_return_val_if_fail (EMPATHY_IS_CONTACT_LIST_STORE (store), NULL);
1489
1490 return g_object_new (EMPATHY_TYPE_CONTACT_LIST_VIEW,
1491 "store", store,
1492 "contact-features", contact_features,
1493 "list-features", list_features,
1494 NULL);
1495 }
1496
1497 EmpathyContact *
1498 empathy_contact_list_view_dup_selected (EmpathyContactListView *view)
1499 {
1500 EmpathyContactListViewPriv *priv;
1501 GtkTreeSelection *selection;
1502 GtkTreeIter iter;
1503 GtkTreeModel *model;
1504 EmpathyContact *contact;
1505
1506 g_return_val_if_fail (EMPATHY_IS_CONTACT_LIST_VIEW (view), NULL);
1507
1508 priv = GET_PRIV (view);
1509
1510 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
1511 if (!gtk_tree_selection_get_selected (selection, &model, &iter)) {
1512 return NULL;
1513 }
1514
1515 gtk_tree_model_get (model, &iter,
1516 EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact,
1517 -1);
1518
1519 return contact;
1520 }
1521
1522 EmpathyContactListFlags
1523 empathy_contact_list_view_get_flags (EmpathyContactListView *view)
1524 {
1525 EmpathyContactListViewPriv *priv;
1526 GtkTreeSelection *selection;
1527 GtkTreeIter iter;
1528 GtkTreeModel *model;
1529 EmpathyContactListFlags flags;
1530
1531 g_return_val_if_fail (EMPATHY_IS_CONTACT_LIST_VIEW (view), 0);
1532
1533 priv = GET_PRIV (view);
1534
1535 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
1536 if (!gtk_tree_selection_get_selected (selection, &model, &iter)) {
1537 return 0;
1538 }
1539
1540 gtk_tree_model_get (model, &iter,
1541 EMPATHY_CONTACT_LIST_STORE_COL_FLAGS, &flags,
1542 -1);
1543
1544 return flags;
1545 }
1546
1547 gchar *
1548 empathy_contact_list_view_get_selected_group (EmpathyContactListView *view)
1549 {
1550 EmpathyContactListViewPriv *priv;
1551 GtkTreeSelection *selection;
1552 GtkTreeIter iter;
1553 GtkTreeModel *model;
1554 gboolean is_group;
1555 gchar *name;
1556
1557 g_return_val_if_fail (EMPATHY_IS_CONTACT_LIST_VIEW (view), NULL);
1558
1559 priv = GET_PRIV (view);
1560
1561 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
1562 if (!gtk_tree_selection_get_selected (selection, &model, &iter)) {
1563 return NULL;
1564 }
1565
1566 gtk_tree_model_get (model, &iter,
1567 EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, &is_group,
1568 EMPATHY_CONTACT_LIST_STORE_COL_NAME, &name,
1569 -1);
1570
1571 if (!is_group) {
1572 g_free (name);
1573 return NULL;
1574 }
1575
1576 return name;
1577 }
1578
1579 static gboolean
1580 contact_list_view_remove_dialog_show (GtkWindow *parent,
1581 const gchar *message,
1582 const gchar *secondary_text)
1583 {
1584 GtkWidget *dialog;
1585 gboolean res;
1586
1587 dialog = gtk_message_dialog_new (parent, GTK_DIALOG_MODAL,
1588 GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE,
1589 "%s", message);
1590 gtk_dialog_add_buttons (GTK_DIALOG (dialog),
1591 GTK_STOCK_CANCEL, GTK_RESPONSE_NO,
1592 GTK_STOCK_DELETE, GTK_RESPONSE_YES,
1593 NULL);
1594 gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
1595 "%s", secondary_text);
1596
1597 gtk_widget_show (dialog);
1598
1599 res = gtk_dialog_run (GTK_DIALOG (dialog));
1600 gtk_widget_destroy (dialog);
1601
1602 return (res == GTK_RESPONSE_YES);
1603 }
1604
1605 static void
1606 contact_list_view_group_remove_activate_cb (GtkMenuItem *menuitem,
1607 EmpathyContactListView *view)
1608 {
1609 EmpathyContactListViewPriv *priv = GET_PRIV (view);
1610 gchar *group;
1611
1612 group = empathy_contact_list_view_get_selected_group (view);
1613 if (group) {
1614 gchar *text;
1615 GtkWindow *parent;
1616
1617 text = g_strdup_printf (_("Do you really want to remove the group '%s'?"), group);
1618 parent = empathy_get_toplevel_window (GTK_WIDGET (view));
1619 if (contact_list_view_remove_dialog_show (parent, _("Removing group"), text)) {
1620 EmpathyContactList *list;
1621
1622 list = empathy_contact_list_store_get_list_iface (priv->store);
1623 empathy_contact_list_remove_group (list, group);
1624 }
1625
1626 g_free (text);
1627 }
1628
1629 g_free (group);
1630 }
1631
1632 GtkWidget *
1633 empathy_contact_list_view_get_group_menu (EmpathyContactListView *view)
1634 {
1635 EmpathyContactListViewPriv *priv = GET_PRIV (view);
1636 gchar *group;
1637 GtkWidget *menu;
1638 GtkWidget *item;
1639 GtkWidget *image;
1640
1641 g_return_val_if_fail (EMPATHY_IS_CONTACT_LIST_VIEW (view), NULL);
1642
1643 if (!(priv->list_features & (EMPATHY_CONTACT_LIST_FEATURE_GROUPS_RENAME |
1644 EMPATHY_CONTACT_LIST_FEATURE_GROUPS_REMOVE))) {
1645 return NULL;
1646 }
1647
1648 group = empathy_contact_list_view_get_selected_group (view);
1649 if (!group) {
1650 return NULL;
1651 }
1652
1653 menu = gtk_menu_new ();
1654
1655 /* FIXME: Not implemented yet
1656 if (priv->features & EMPATHY_CONTACT_LIST_FEATURE_GROUPS_RENAME) {
1657 item = gtk_menu_item_new_with_mnemonic (_("Re_name"));
1658 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1659 gtk_widget_show (item);
1660 g_signal_connect (item, "activate",
1661 G_CALLBACK (contact_list_view_group_rename_activate_cb),
1662 view);
1663 }*/
1664
1665 if (priv->list_features & EMPATHY_CONTACT_LIST_FEATURE_GROUPS_REMOVE) {
1666 item = gtk_image_menu_item_new_with_mnemonic (_("_Remove"));
1667 image = gtk_image_new_from_icon_name (GTK_STOCK_REMOVE,
1668 GTK_ICON_SIZE_MENU);
1669 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1670 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1671 gtk_widget_show (item);
1672 g_signal_connect (item, "activate",
1673 G_CALLBACK (contact_list_view_group_remove_activate_cb),
1674 view);
1675 }
1676
1677 g_free (group);
1678
1679 return menu;
1680 }
1681
1682 static void
1683 contact_list_view_remove_activate_cb (GtkMenuItem *menuitem,
1684 EmpathyContactListView *view)
1685 {
1686 EmpathyContactListViewPriv *priv = GET_PRIV (view);
1687 EmpathyContact *contact;
1688
1689 contact = empathy_contact_list_view_dup_selected (view);
1690
1691 if (contact) {
1692 gchar *text;
1693 GtkWindow *parent;
1694
1695 parent = empathy_get_toplevel_window (GTK_WIDGET (view));
1696 text = g_strdup_printf (_("Do you really want to remove the contact '%s'?"),
1697 empathy_contact_get_name (contact));
1698 if (contact_list_view_remove_dialog_show (parent, _("Removing contact"), text)) {
1699 EmpathyContactList *list;
1700
1701 list = empathy_contact_list_store_get_list_iface (priv->store);
1702 empathy_contact_list_remove (list, contact, "");
1703 }
1704
1705 g_free (text);
1706 g_object_unref (contact);
1707 }
1708 }
1709
1710 GtkWidget *
1711 empathy_contact_list_view_get_contact_menu (EmpathyContactListView *view)
1712 {
1713 EmpathyContactListViewPriv *priv = GET_PRIV (view);
1714 EmpathyContact *contact;
1715 GtkWidget *menu;
1716 GtkWidget *item;
1717 GtkWidget *image;
1718 EmpathyContactListFlags flags;
1719
1720 g_return_val_if_fail (EMPATHY_IS_CONTACT_LIST_VIEW (view), NULL);
1721
1722 contact = empathy_contact_list_view_dup_selected (view);
1723 if (!contact) {
1724 return NULL;
1725 }
1726 flags = empathy_contact_list_view_get_flags (view);
1727
1728 menu = empathy_contact_menu_new (contact, priv->contact_features);
1729
1730 /* Remove contact */
1731 if (priv->list_features & EMPATHY_CONTACT_LIST_FEATURE_CONTACT_REMOVE &&
1732 flags & EMPATHY_CONTACT_LIST_CAN_REMOVE) {
1733 /* create the menu if required, or just add a separator */
1734 if (!menu) {
1735 menu = gtk_menu_new ();
1736 } else {
1737 item = gtk_separator_menu_item_new ();
1738 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1739 gtk_widget_show (item);
1740 }
1741
1742 /* Remove */
1743 item = gtk_image_menu_item_new_with_mnemonic (_("_Remove"));
1744 image = gtk_image_new_from_icon_name (GTK_STOCK_REMOVE,
1745 GTK_ICON_SIZE_MENU);
1746 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
1747 gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
1748 gtk_widget_show (item);
1749 g_signal_connect (item, "activate",
1750 G_CALLBACK (contact_list_view_remove_activate_cb),
1751 view);
1752 }
1753
1754 g_object_unref (contact);
1755
1756 return menu;
1757 }
1758
empathy mirror